package com.sg.service.biz.framework.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.framework.req.*;
import com.sg.dto.biz.framework.req.*;
import com.sg.dto.biz.framework.res.*;
import com.sg.dto.integration.component.QueryItemMatchResultToAnswerDetailComReqDto;
import com.sg.dto.integration.component.QueryItemMatchResultToAnswerDetailComRespDto;
import com.sg.service.biz.framework.*;
import com.wicket.okrcomponent.integration.ConfSchemeService;
import com.sg.common.exception.Assert;
import com.wicket.okrframework.common.exception.BizException;
import com.wicket.okrframework.dal.po.mbg.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
@Slf4j
public class BatchServiceImpl
        implements com.wicket.okrframework.biz.service.BatchService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MBatchService mBatchService;
    @Resource
    private MOrganizationService mOrganizationService;
    @Resource
    private MInductionRecordService mInductionRecordService;
    @Resource
    private MChangeColumnService mChangeColumnService;
    @Resource
    private MStaffingService mStaffingService;
    @Resource
    private MPrivacyDistributionService mPrivacyDistributionService;
    @Resource
    private MDeptPositionRelationshipService mDeptPositionRelationshipService;
    @Resource
    private MPositionService mPositionService;
    @Resource
    private MStaffingAccountService mStaffingAccountService;
    @Resource
    private NbBatch nbBatch;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private OffStateService offStateService;
    @Resource
    private ChangeColumnService changeColumnService;
    @Resource
    private StaffingService staffingService;
    @Resource
    private PowerService powerService;
    @Resource
    private OrgPositionService orgPositionService;
    @Resource
    private MStatusCheckItemService mStatusCheckItemService;
    @Resource
    private MTypeDictionaryService mTypeDictionaryService;
    @Resource
    private MDeptService mDeptService;
    @Resource
    private OrgService orgService;
    @Resource
    private InductionRecordService inductionRecordService;
    @Resource
    private MemberService memberService;
//@Resource
    //private MCustomFields2Service mCustomFields2Service;
    // @Resource
    // private MSpecMethordTableService mSpecMethordTableService;
    // @Resource
    // private undefinedService undefinedService;


    /**
     * D1-1查询底层框架服务批次列表[264]
     * gen by moon at 10/2/2022, 2:58:19 AM
     */
    @Trace(operationName = "D1-1查询底层框架服务批次列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryBaseBatchListRespDto queryBaseBatchList(QueryBaseBatchListReqDto reqDto) {


        List<Batch> listBatch_1 = new ArrayList<>();
//步骤0: 1-1-01查询底层框架服务批次列表 - queryBaseBatchList
        List<Batch> listBatch = new ArrayList<>();
        QueryBaseBatchListReq queryBaseBatchListReq = new QueryBaseBatchListReq();
        queryBaseBatchListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23612_1
        queryBaseBatchListReq.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23613_1
        if (reqDto != null) {
            queryBaseBatchListReq.setPurposeTypeCode(reqDto.getPurposeTypeCode());//SimpleFieldAssign//sourceId:3883_1
            queryBaseBatchListReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:3884_1
            queryBaseBatchListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:17424_1
            queryBaseBatchListReq.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:19810_1
        }

        /*1-1-01查询底层框架服务批次列表[227]   */
        Assert.isNull(queryBaseBatchListReq.getPurposeTypeCode(), "D1-1查询底层框架服务批次列表-1-1-01查询底层框架服务批次列表-用途类型编码不能为空", false);
        Assert.isNull(queryBaseBatchListReq.getAscriptionObjectId(), "D1-1查询底层框架服务批次列表-1-1-01查询底层框架服务批次列表-归属对象ID不能为空", false);
        Assert.isNull(queryBaseBatchListReq.getSpaceId(), "D1-1查询底层框架服务批次列表-1-1-01查询底层框架服务批次列表-创建于空间ID不能为空", false);
        Assert.isNull(queryBaseBatchListReq.getAppId(), "D1-1查询底层框架服务批次列表-1-1-01查询底层框架服务批次列表-创建于联盟应用ID不能为空", false);
        listBatch = mBatchService.queryBaseBatchList(queryBaseBatchListReq);


        listBatch_1 = listBatch;

        QueryBaseBatchListRespDto retData = new QueryBaseBatchListRespDto();
        retData.setBaseBatchList(listBatch_1.stream().map(item -> BeanUtil.toBean(item, BaseBatchDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:3907_1


        return retData;
    }

    /**
     * D1-1新增底层框架服务批次[242]
     * gen by moon at 8/10/2022, 3:21:29 AM
     */
    @Trace(operationName = "D1-1新增底层框架服务批次")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddBaseBatchRespDto addBaseBatch(AddBaseBatchReqDto reqDto) {


        Batch batch_1 = null;
        String string_1 = null;
//virtualUsage 查询是否有正在编辑的批次，避免重复  1583
        Batch batch = null;
        QueryBaseBatchDetailReq queryBaseBatchDetailReq = new QueryBaseBatchDetailReq();
        queryBaseBatchDetailReq.setSubjectLifeCycle("EDITING");//sourceId:3549_1_1583
        if (reqDto != null) {
            queryBaseBatchDetailReq.setPurposeTypeCode(reqDto.getPurposeTypeCode());//sourceId:23717_1_1583
            queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//sourceId:13588_1_1583
        }

    /*查询是否有正在编辑的批次，避免重复[44] 批次生命周期入参        正在编辑：EDITING
如果批次ID 存在，返回批次ID，批次ID 不存在，返回-1，返回-1才执行下一步虚拟用况  */
        Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(), "D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-用途类型编码不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(), "D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-归属对象ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(), "D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-主体生命周期不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getSpaceId(), "D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-创建于空间ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getAppId(), "D1-1新增底层框架服务批次-查询是否有正在编辑的批次，避免重复-创建于联盟应用ID不能为空", false);
        batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);

        batch_1 = batch;
        if ((ObjectUtil.isEmpty(batch))) {
            //if(查询是否有正在编辑的批次，避免重复.出参 等于空 )  1584

            String string = null;
            Batch batch_2 = new Batch();
            batch_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23641_1_1585
            batch_2.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23642_1_1585
            if (reqDto != null) {
                batch_2.setPurposeTypeCode(reqDto.getPurposeTypeCode());//sourceId:3459_1_1585
                batch_2.setAscriptionObjectId(reqDto.getAscriptionObjectId());//sourceId:3460_1_1585
                batch_2.setIsFirst(reqDto.getIsFirst());//sourceId:17396_1_1585
            }

            /*1-1-01新增底层框架服务批次[41]   */
            Assert.isNull(batch_2.getPurposeTypeCode(), "D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-用途类型编码不能为空", false);
            Assert.isNull(batch_2.getAscriptionObjectId(), "D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-归属对象ID不能为空", false);
            Assert.isNull(batch_2.getIsFirst(), "D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-是否首次批次不能为空", false);
            Assert.isNull(batch_2.getSpaceId(), "D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-创建于空间ID不能为空", false);
            Assert.isNull(batch_2.getAppId(), "D1-1新增底层框架服务批次-1-1-01新增底层框架服务批次-创建于联盟应用ID不能为空", false);
            string = mBatchService.addBaseBatch(batch_2);

            string_1 = string;
            UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
            UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto = new UpdateCheckItemStatComReqDto();
            updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:144788_1_8669
            updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:144789_1_8669
            updateCheckItemStatComReqDto.setIsComplete("FALSE");//sourceId:144787_1_8669
            if (reqDto != null) {
                updateCheckItemStatComReqDto.setEntityId(reqDto.getAscriptionObjectId());
                ;//sourceId:144790_1_8669
            }

            /*D1-1修改检查项状态(公共)[947]   */
            Assert.isNull(updateCheckItemStatComReqDto, "D1-1新增底层框架服务批次-D1-1修改检查项状态(公共)-检查项标识不能为空", false);
            Assert.isNull(updateCheckItemStatComReqDto, "D1-1新增底层框架服务批次-D1-1修改检查项状态(公共)-内容对象类型编码不能为空", false);
            Assert.isNull(updateCheckItemStatComReqDto, "D1-1新增底层框架服务批次-D1-1修改检查项状态(公共)-内容对象实例ID不能为空", false);
            Assert.isNull(updateCheckItemStatComReqDto, "D1-1新增底层框架服务批次-D1-1修改检查项状态(公共)-是否已完成不能为空", false);
            updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);


        } else {
            //else  8486

//processBranchName:正常结束 ,processBranchId:8487

        }
        AddBaseBatchRespDto retData = new AddBaseBatchRespDto();
        if (batch_1 != null) {
            retData.setBatchId(batch_1.getBatchId());//sourceId:56487_1
        }
        if (string_1 != null) {
            retData.setBatchId(string_1);//sourceId:56487_1
        }


        return retData;
    }

    /**
     * D1-1查询底层框架服务批次详情[1805]
     * gen by moon at 10/2/2022, 12:45:38 AM
     */
    @Trace(operationName = "D1-1查询底层框架服务批次详情")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryBaseBatchDetailRespDto queryBaseBatchDetail(QueryBaseBatchDetailReqDto reqDto) {


        Batch batch_1 = null;
//步骤0: 1-1-01查询底层框架服务批次详情 - queryBaseBatchDetail
        Batch batch = null;
        QueryBaseBatchDetailReq queryBaseBatchDetailReq = new QueryBaseBatchDetailReq();
        if (reqDto != null) {
            queryBaseBatchDetailReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:55140_1
            queryBaseBatchDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:259682_1
        }

        /*1-1-01查询底层框架服务批次详情[44]   */
        Assert.isNull(queryBaseBatchDetailReq.getBatchId(), "D1-1查询底层框架服务批次详情-1-1-01查询底层框架服务批次详情-批次ID不能为空", false);
        batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);


        batch_1 = batch;

        QueryBaseBatchDetailRespDto retData = new QueryBaseBatchDetailRespDto();
        if (batch_1 != null) {
            retData.setBatchId(batch_1.getBatchId());//SimpleFieldAssign//sourceId:55142_1
            retData.setIsFirst(batch_1.getIsFirst());//SimpleFieldAssign//sourceId:55143_1
            retData.setSubjectLifeCycle(batch_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:55144_1
            retData.setIsEditing(batch_1.getIsEditing());//SimpleFieldAssign//sourceId:55145_1
        }


        return retData;
    }

    /**
     * D1-1撤销修订组织架构底层批次自身处理(公共)[3741]
     * gen by moon at 10/1/2022, 11:48:42 PM
     */
    @Trace(operationName = "D1-1撤销修订组织架构底层批次自身处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UndoReviseOrgBaseBatchOwnHandleComRespDto undoReviseOrgBaseBatchOwnHandleCom(UndoReviseOrgBaseBatchOwnHandleComReqDto reqDto) {


        //步骤0: 1-1-01查询底层框架服务批次详情 - queryBaseBatchDetail
        Batch batch = null;
        QueryBaseBatchDetailReq queryBaseBatchDetailReq = new QueryBaseBatchDetailReq();
        queryBaseBatchDetailReq.setIsNewbatch("TRUE");//sourceId:261586_1
        queryBaseBatchDetailReq.setSubjectLifeCycle("EDITING");//sourceId:175863_1
        if (reqDto != null) {
            queryBaseBatchDetailReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:175862_1
        }

        /*1-1-01查当前正在编辑底层框架服务批次[44]   */
        Assert.isNull(queryBaseBatchDetailReq.getBatchId(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查当前正在编辑底层框架服务批次-批次ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getIsNewbatch(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查当前正在编辑底层框架服务批次-是否最新批次不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查当前正在编辑底层框架服务批次-主体生命周期不能为空", false);
        batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);
        Assert.isTrue(batch == null || batch.getBatchId() == null, "返回值不能为空", false);


//步骤1: 1-1-01删除底层框架服务批次	 - deleteBaseBatch
        boolean bOOLEAN;
        if (batch != null) {
            String string = new String();
            if (batch != null) {
                string = batch.getBatchId();
                ;//SimpleFieldAssign//sourceId:175865_1
            }

            /*1-1-01删除当前正在编辑底层框架服务批次[43]   */
            Assert.isNull(string, "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01删除当前正在编辑底层框架服务批次-批次ID不能为空", false);
            bOOLEAN = mBatchService.deleteBaseBatch(string);


        }

//步骤2: 1-1-01查询底层框架服务批次详情 - queryBaseBatchDetail
        Batch batch_2 = null;
        if (batch != null) {
            QueryBaseBatchDetailReq queryBaseBatchDetailReq_1 = new QueryBaseBatchDetailReq();
            queryBaseBatchDetailReq_1.setPurposeTypeCode("ORG");//sourceId:284994_1
            queryBaseBatchDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:285000_1
            if (batch != null) {
                queryBaseBatchDetailReq_1.setAscriptionObjectId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:284995_1
            }

            /*1-1-01查询上一批次[44]   */
            Assert.isNull(queryBaseBatchDetailReq_1.getAscriptionObjectId(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查询上一批次-归属对象ID不能为空", false);
            Assert.isNull(queryBaseBatchDetailReq_1.getPurposeTypeCode(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查询上一批次-用途类型编码不能为空", false);
            Assert.isNull(queryBaseBatchDetailReq_1.getSubjectLifeCycle(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01查询上一批次-主体生命周期不能为空", false);
            batch_2 = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq_1);
            Assert.isTrue(batch_2 == null || batch_2.getBatchId() == null, "返回值不能为空", false);


        }

//步骤3: 1-1-01修改底层框架服务批次	 - updateBaseBatch
        boolean bOOLEAN_1;
        if (batch_2 != null) {
            Batch batch_4 = new Batch();
            batch_4.setIsNewbatch("TRUE");//sourceId:285074_1
            batch_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:285040_1
            batch_4.setIsArchive("FALSE");//sourceId:285047_1
            batch_4.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:285044_1
            batch_4.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:285045_1
            if (batch_2 != null) {
                batch_4.setBatchId(batch_2.getBatchId());//SimpleFieldAssign//sourceId:285035_1
            }

            /*1-1-01恢复上一批次生命周期状态[42]   */
            Assert.isNull(batch_4.getBatchId(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-批次ID不能为空", false);
            Assert.isNull(batch_4.getIsNewbatch(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-是否最新批次不能为空", false);
            Assert.isNull(batch_4.getSubjectLifeCycle(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-主体生命周期不能为空", false);
            Assert.isNull(batch_4.getIsArchive(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-是否存档不能为空", false);
            Assert.isNull(batch_4.getOperationInductionId(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-操作人就职记录ID不能为空", false);
            Assert.isNull(batch_4.getOperateTime(), "D1-1撤销修订组织架构底层批次自身处理(公共)-1-1-01恢复上一批次生命周期状态-操作时间不能为空", false);
            bOOLEAN_1 = mBatchService.updateBaseBatch(batch_4);


        }

        UndoReviseOrgBaseBatchOwnHandleComRespDto retData = new UndoReviseOrgBaseBatchOwnHandleComRespDto();


        return retData;
    }

    /**
     * D1-1发布组织架构底层批次自身处理(公共)[3740]
     * gen by moon at 10/1/2022, 11:48:54 PM
     */
    @Trace(operationName = "D1-1发布组织架构底层批次自身处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReleaseOrgBaseBatchOwnHandleComRespDto releaseOrgBaseBatchOwnHandleCom(ReleaseOrgBaseBatchOwnHandleComReqDto reqDto) {


        //步骤0: 1-1-01查询底层框架服务批次详情 - queryBaseBatchDetail
        Batch batch = null;
        QueryBaseBatchDetailReq queryBaseBatchDetailReq = new QueryBaseBatchDetailReq();
        queryBaseBatchDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:175804_1
        if (reqDto != null) {
            queryBaseBatchDetailReq.setPurposeTypeCode(reqDto.getPurposeTypeCode());//SimpleFieldAssign//sourceId:175802_1
            queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:175803_1
        }

        /*1-1-01查上一底层框架批次（用于历史存档）[44]   */
        Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01查上一底层框架批次（用于历史存档）-用途类型编码不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01查上一底层框架批次（用于历史存档）-归属对象ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01查上一底层框架批次（用于历史存档）-主体生命周期不能为空", false);
        batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);


//步骤1: 1-1-01修改底层框架服务批次	 - updateBaseBatch
        boolean bOOLEAN;
        if (batch != null) {
            Batch batch_2 = new Batch();
            batch_2.setBatchEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175790_1
            batch_2.setSubjectLifeCycle("ARCHIVING");//sourceId:175791_1
            batch_2.setIsNewbatch("FALSE");//sourceId:246853_1
            batch_2.setIsArchive("TRUE");//sourceId:175792_1
            batch_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:175812_1
            batch_2.setArchiveInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:175813_1
            batch_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175814_1
            batch_2.setArchiveTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175815_1
            if (batch != null) {
                batch_2.setBatchId(batch.getBatchId());//SimpleFieldAssign//sourceId:175786_1
            }

            /*1-1-01修改上一底层框架批次历史存档[42]   */
            Assert.isNull(batch_2.getBatchId(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-批次ID不能为空", false);
            Assert.isNull(batch_2.getBatchEndTime(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-批次结束时间不能为空", false);
            Assert.isNull(batch_2.getSubjectLifeCycle(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-主体生命周期不能为空", false);
            Assert.isNull(batch_2.getIsNewbatch(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-是否最新批次不能为空", false);
            Assert.isNull(batch_2.getIsArchive(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-是否存档不能为空", false);
            Assert.isNull(batch_2.getOperationInductionId(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-操作人就职记录ID不能为空", false);
            Assert.isNull(batch_2.getArchiveInductionId(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-存档人就职记录ID不能为空", false);
            Assert.isNull(batch_2.getOperateTime(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-操作时间不能为空", false);
            Assert.isNull(batch_2.getArchiveTime(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改上一底层框架批次历史存档-存档时间不能为空", false);
            bOOLEAN = mBatchService.updateBaseBatch(batch_2);


        }

//步骤2: 1-1-01修改底层框架服务批次	 - updateBaseBatch
        boolean bOOLEAN_1;
        Batch batch_3 = new Batch();
        batch_3.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175797_1
        batch_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:175799_1
        batch_3.setIsEditing("FALSE");//sourceId:175801_1
        batch_3.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:175808_1
        batch_3.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:175809_1
        batch_3.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175810_1
        batch_3.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:175811_1
        if (reqDto != null) {
            batch_3.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:175794_1
        }

        /*1-1-01修改当前底层框架服务批次为当前有效[42]   */
        Assert.isNull(batch_3.getBatchId(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-批次ID不能为空", false);
        Assert.isNull(batch_3.getBatchStartTime(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-批次开始时间不能为空", false);
        Assert.isNull(batch_3.getSubjectLifeCycle(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-主体生命周期不能为空", false);
        Assert.isNull(batch_3.getIsEditing(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-是否未来不能为空", false);
        Assert.isNull(batch_3.getOperationInductionId(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-操作人就职记录ID不能为空", false);
        Assert.isNull(batch_3.getReleaseInductionId(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-发布人就职记录ID不能为空", false);
        Assert.isNull(batch_3.getOperateTime(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-操作时间不能为空", false);
        Assert.isNull(batch_3.getReleaseTime(), "D1-1发布组织架构底层批次自身处理(公共)-1-1-01修改当前底层框架服务批次为当前有效-发布时间不能为空", false);
        bOOLEAN_1 = mBatchService.updateBaseBatch(batch_3);


        ReleaseOrgBaseBatchOwnHandleComRespDto retData = new ReleaseOrgBaseBatchOwnHandleComRespDto();


        return retData;
    }

    /**
     * D1-1撤销组织架构成员基础批次处理(公共)[3727]
     * gen by moon at 10/1/2022, 11:53:29 PM
     */
    @Trace(operationName = "D1-1撤销组织架构成员基础批次处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UndoOrgBaseBatchProcessingComRespDto undoOrgBaseBatchProcessingCom(UndoOrgBaseBatchProcessingComReqDto reqDto) {


        //步骤0: D1-1撤销修订组织架构底层批次自身处理(公共) - undoReviseOrgBaseBatchOwnHandleCom
        UndoReviseOrgBaseBatchOwnHandleComRespDto undoReviseOrgBaseBatchOwnHandleComRespDto = null;
        UndoReviseOrgBaseBatchOwnHandleComReqDto undoReviseOrgBaseBatchOwnHandleComReqDto = new UndoReviseOrgBaseBatchOwnHandleComReqDto();
        if (reqDto != null) {
            undoReviseOrgBaseBatchOwnHandleComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:175875_1
        }

        /*D1-1撤销修订组织架构底层批次自身处理(公共)[3741]   */
        Assert.isNull(undoReviseOrgBaseBatchOwnHandleComReqDto.getBatchId(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1撤销修订组织架构底层批次自身处理(公共)-批次ID不能为空", false);
        undoReviseOrgBaseBatchOwnHandleComRespDto = undoReviseOrgBaseBatchOwnHandleCom(undoReviseOrgBaseBatchOwnHandleComReqDto);


//步骤1: D1-1撤销修订组织架构批次处理变更字段(公共) - undoReviseOrgBatchHandleChangeColCom
        UndoReviseOrgBatchHandleChangeColComRespDto undoReviseOrgBatchHandleChangeColComRespDto = null;
        UndoReviseOrgBatchHandleChangeColComReqDto undoReviseOrgBatchHandleChangeColComReqDto = new UndoReviseOrgBatchHandleChangeColComReqDto();
        undoReviseOrgBatchHandleChangeColComReqDto.setObjectTypeCode("OMS_ORG_ORGANIZATION");//sourceId:176408_1
        if (reqDto != null) {
            undoReviseOrgBatchHandleChangeColComReqDto.setObjectId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176409_1
            undoReviseOrgBatchHandleChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176410_1
        }

        /*D1-1撤销修订组织架构批次处理变更字段(公共)[3743]   */
        Assert.isNull(undoReviseOrgBatchHandleChangeColComReqDto.getObjectTypeCode(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1撤销修订组织架构批次处理变更字段(公共)-归属对象类型编码不能为空", false);
        Assert.isNull(undoReviseOrgBatchHandleChangeColComReqDto.getObjectId(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1撤销修订组织架构批次处理变更字段(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(undoReviseOrgBatchHandleChangeColComReqDto.getBatchId(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1撤销修订组织架构批次处理变更字段(公共)-批次ID不能为空", false);
        undoReviseOrgBatchHandleChangeColComRespDto = changeColumnService.undoReviseOrgBatchHandleChangeColCom(undoReviseOrgBatchHandleChangeColComReqDto);


//步骤2: D1-1修改检查项状态(公共) - updateCheckItemStatCom
        UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
        UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto = new UpdateCheckItemStatComReqDto();
        updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:194302_1
        updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:194303_1
        updateCheckItemStatComReqDto.setIsComplete("TRUE");//sourceId:194301_1
        if (reqDto != null) {
            updateCheckItemStatComReqDto.setEntityId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:194304_1
        }

        /*D1-1修改组织成员管理检查项状态为完成[947]   */
        Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织成员管理检查项状态为完成-检查项标识不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织成员管理检查项状态为完成-内容对象类型编码不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto.getEntityId(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织成员管理检查项状态为完成-内容对象实例ID不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织成员管理检查项状态为完成-是否已完成不能为空", false);
        updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);


//步骤3: D1-1修改检查项状态(公共) - updateCheckItemStatCom
        UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto_1 = null;
        UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto_1 = new UpdateCheckItemStatComReqDto();
        updateCheckItemStatComReqDto_1.setCheckItemCode("ORG_MGT_CHECK");//CUSTOM_CONVENTION//sourceId:284990_1
        updateCheckItemStatComReqDto_1.setObjectTypeCode("ORG_CHECK");//sourceId:284991_1
        updateCheckItemStatComReqDto_1.setIsComplete("TRUE");//sourceId:284989_1
        if (reqDto != null) {
            updateCheckItemStatComReqDto_1.setEntityId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:284992_1
        }

        /*D1-1修改组织管理检查项状态已完成[947]   */
        Assert.isNull(updateCheckItemStatComReqDto_1.getCheckItemCode(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织管理检查项状态已完成-检查项标识不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto_1.getObjectTypeCode(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织管理检查项状态已完成-内容对象类型编码不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto_1.getEntityId(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织管理检查项状态已完成-内容对象实例ID不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto_1.getIsComplete(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-1修改组织管理检查项状态已完成-是否已完成不能为空", false);
        updateCheckItemStatComRespDto_1 = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto_1);


//步骤4: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
        RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
        RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto = new RefreshMemberBatchProgressComReqDto();
        refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(80L);//CUSTOM_CONVENTION//sourceId:175490_1
        refreshMemberBatchProgressComReqDto.setBatchHandleStep("2");//CUSTOM_CONVENTION//sourceId:175491_1
        refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_DELETE_BATCH");//sourceId:175492_1
        refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318748_1
        refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318749_1
        refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318750_1
        if (reqDto != null) {
            refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279738_1
        }

        /*D1-3更新组织架构成员批次处理进度80(公共)[3723]   */
        Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-组织ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理进度不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理步骤不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理类型不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建于空间ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(), "D1-1撤销组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建于联盟应用ID不能为空", false);
        refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto);


        UndoOrgBaseBatchProcessingComRespDto retData = new UndoOrgBaseBatchProcessingComRespDto();


        return retData;
    }

    /**
     * D1-1发布组织架构成员基础批次处理(公共)[3726]
     * gen by moon at 9/20/2023, 11:29:37 PM
     */
    @Trace(operationName = "D1-1发布组织架构成员基础批次处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReleaseOrgBaseBatchProcessingComRespDto releaseOrgBaseBatchProcessingCom(ReleaseOrgBaseBatchProcessingComReqDto reqDto) {


        //步骤0: D1-1发布组织架构底层批次自身处理(公共) - releaseOrgBaseBatchOwnHandleCom
        ReleaseOrgBaseBatchOwnHandleComRespDto releaseOrgBaseBatchOwnHandleComRespDto = null;
        ReleaseOrgBaseBatchOwnHandleComReqDto releaseOrgBaseBatchOwnHandleComReqDto = new ReleaseOrgBaseBatchOwnHandleComReqDto();
        releaseOrgBaseBatchOwnHandleComReqDto.setPurposeTypeCode("ORG");//sourceId:175817_1
        if (reqDto != null) {
            releaseOrgBaseBatchOwnHandleComReqDto.setAscriptionObjectId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:175818_1
            releaseOrgBaseBatchOwnHandleComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:175819_1
        }

        /*D1-1发布组织架构底层批次自身处理(公共)[3740]   */
        Assert.isNull(releaseOrgBaseBatchOwnHandleComReqDto.getPurposeTypeCode(), "D1-1发布组织架构成员基础批次处理(公共)-D1-1发布组织架构底层批次自身处理(公共)-用途类型编码不能为空", false);
        Assert.isNull(releaseOrgBaseBatchOwnHandleComReqDto.getAscriptionObjectId(), "D1-1发布组织架构成员基础批次处理(公共)-D1-1发布组织架构底层批次自身处理(公共)-归属对象ID不能为空", false);
        Assert.isNull(releaseOrgBaseBatchOwnHandleComReqDto.getBatchId(), "D1-1发布组织架构成员基础批次处理(公共)-D1-1发布组织架构底层批次自身处理(公共)-批次ID不能为空", false);
        releaseOrgBaseBatchOwnHandleComRespDto = releaseOrgBaseBatchOwnHandleCom(releaseOrgBaseBatchOwnHandleComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤1: D1-1更新批次处理组织架构变更字段(公共) - refreshBatchProcessingOrgChangeColCom
        RefreshBatchProcessingOrgChangeColComRespDto refreshBatchProcessingOrgChangeColComRespDto = null;
        RefreshBatchProcessingOrgChangeColComReqDto refreshBatchProcessingOrgChangeColComReqDto = new RefreshBatchProcessingOrgChangeColComReqDto();
        refreshBatchProcessingOrgChangeColComReqDto.setObjectTypeCode("OMS_ORG_ORGANIZATION");//sourceId:306223_1
        if (reqDto != null) {
            refreshBatchProcessingOrgChangeColComReqDto.setObjectId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:306224_1
            refreshBatchProcessingOrgChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:306225_1
        }

        /*D1-1更新批次处理组织架构变更字段(公共)[3742]   */
        Assert.isNull(refreshBatchProcessingOrgChangeColComReqDto.getObjectTypeCode(), "D1-1发布组织架构成员基础批次处理(公共)-D1-1更新批次处理组织架构变更字段(公共)-归属对象类型编码不能为空", false);
        Assert.isNull(refreshBatchProcessingOrgChangeColComReqDto.getObjectId(), "D1-1发布组织架构成员基础批次处理(公共)-D1-1更新批次处理组织架构变更字段(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(refreshBatchProcessingOrgChangeColComReqDto.getBatchId(), "D1-1发布组织架构成员基础批次处理(公共)-D1-1更新批次处理组织架构变更字段(公共)-批次ID不能为空", false);
        refreshBatchProcessingOrgChangeColComRespDto = changeColumnService.refreshBatchProcessingOrgChangeColCom(refreshBatchProcessingOrgChangeColComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
        RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
        RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto = new RefreshMemberBatchProgressComReqDto();
        refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(Long.valueOf(80));//CUSTOM_CONVENTION//sourceId:264452_1
        refreshMemberBatchProgressComReqDto.setBatchHandleStep("2");//CUSTOM_CONVENTION//sourceId:175471_1
        refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_BATCH_PUBLISH");//sourceId:175472_1
        refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318745_1
        refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318746_1
        refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318747_1
        if (reqDto != null) {
            refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279718_1
        }

        /*D1-3更新组织架构成员批次处理进度80(公共)[3723]   */
        Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(), "D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-组织ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(), "D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理进度不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(), "D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-处理步骤不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(), "D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-批次处理类型不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(), "D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(), "D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建于空间ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(), "D1-1发布组织架构成员基础批次处理(公共)-D1-3更新组织架构成员批次处理进度80(公共)-创建于联盟应用ID不能为空", false);
        refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto)/*vcase invoke 同服务,同domain*/;


        ReleaseOrgBaseBatchProcessingComRespDto retData = new ReleaseOrgBaseBatchProcessingComRespDto();


        return retData;
    }

    /**
     * D1-3撤销就职记录相关批次处理(公共)[3725]
     * gen by moon at 10/16/2022, 1:54:11 AM
     */
    @Trace(operationName = "D1-3撤销就职记录相关批次处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UndoInductionRecordBatchProcessingComRespDto undoInductionRecordBatchProcessingCom(UndoInductionRecordBatchProcessingComReqDto reqDto) {


        //步骤0: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
        queryInductionRecordListReq.setUpdateStatus("NEW");//sourceId:176575_1
        queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:176576_1
        if (reqDto != null) {
            queryInductionRecordListReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176573_1
            queryInductionRecordListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176574_1
        }

        /*1-3-13查本次新增就职记录列表[166]   */
        Assert.isNull(queryInductionRecordListReq.getOrganizationId(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-组织ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getBatchId(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-批次ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getUpdateStatus(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-批次下更新状态不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSpaceId(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-创建于空间ID不能为空", false);
        listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


//步骤1: 1-3-13批量删除就职记录 - batchDeleteInductionRecord
        boolean bOOLEAN;
        if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord.size() > 0) {
            List<String> listString = new ArrayList<>();
            listString = listInductionRecord.stream().map(item -> item.getInductionRecordId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:176480_1

            /*1-3-13批量删除就职记录[1685]   */

            bOOLEAN = mInductionRecordService.batchDeleteInductionRecord(listString);


        }

//步骤2: 1-3-14批量查询编制 - batchQueryStaffing
        List<Staffing> listStaffing = new ArrayList<>();
        if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord.size() > 0) {
            BatchQueryStaffingReq batchQueryStaffingReq = new BatchQueryStaffingReq();
            batchQueryStaffingReq.setStaffingList(listInductionRecord.stream().map(item -> item.getStaffingId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:380560_1
            batchQueryStaffingReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:380561_1

            /*1-3-14批量查询编制[3767]   */
            Assert.isNull(batchQueryStaffingReq.getSubjectLifeCycle(), "D1-3撤销就职记录相关批次处理(公共)-1-3-14批量查询编制-主体生命周期不能为空", false);
            listStaffing = mStaffingService.batchQueryStaffing(batchQueryStaffingReq);


        }

//步骤3: 1-3-14批量修改编制 - batchUpdateStaffing
        boolean bOOLEAN_1;
        if (listStaffing != null && !CollectionUtil.isEmpty(listStaffing) && listStaffing.size() > 0) {
            List<Staffing> listStaffing_2 = new ArrayList<>();
            if (listStaffing != null && !CollectionUtil.isEmpty(listStaffing) && listStaffing != null && !CollectionUtil.isEmpty(listStaffing)) {
                listStaffing_2 = listStaffing.stream().map(item -> {
                    Staffing elm = BeanUtil.toBean(item, Staffing.class);
                    elm.setInductionState("FALSE");
                    elm.setTempLock("FALSE");

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:176570_1
            }

            /*1-3-14批量释放编制（有编制的）[931]   */

            bOOLEAN_1 = mStaffingService.batchUpdateStaffing(listStaffing_2);


        }

//步骤4: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq_1 = new QueryInductionRecordListReq();
        queryInductionRecordListReq_1.setUpdateStatus("ARCHIVE");//sourceId:176604_1
        queryInductionRecordListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:176603_1
        if (reqDto != null) {
            queryInductionRecordListReq_1.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176602_1
            queryInductionRecordListReq_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176601_1
        }

        /*1-3-13查本次存档就职记录列表[166]   */
        Assert.isNull(queryInductionRecordListReq_1.getBatchId(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-批次ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq_1.getOrganizationId(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-组织ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq_1.getUpdateStatus(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-批次下更新状态不能为空", false);
        Assert.isNull(queryInductionRecordListReq_1.getSpaceId(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-创建于空间ID不能为空", false);
        listInductionRecord_2 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1);


//步骤5: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN_2;
        if (listInductionRecord_2 != null && !CollectionUtil.isEmpty(listInductionRecord_2) && listInductionRecord_2.size() > 0) {
            List<InductionRecord> listInductionRecord_4 = new ArrayList<>();
            if (listInductionRecord_2 != null && !CollectionUtil.isEmpty(listInductionRecord_2) && listInductionRecord_2 != null && !CollectionUtil.isEmpty(listInductionRecord_2)) {
                listInductionRecord_4 = listInductionRecord_2.stream().map(item -> {
                    InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                    elm.setArchivngType("NOT_ARCHIVE");
                    elm.setIsUpdate("FALSE");
                    elm.setUpdateStatus("UNCHANGED");

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:176606_1
            }

            /*1-3-13批量改就职记录为未存档[1647]   */

            bOOLEAN_2 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_4);


        }

//步骤6: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord_5 = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq_2 = new QueryInductionRecordListReq();
        queryInductionRecordListReq_2.setUpdateStatus("REVISION");//sourceId:176613_1
        queryInductionRecordListReq_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:176614_1
        if (reqDto != null) {
            queryInductionRecordListReq_2.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176611_1
            queryInductionRecordListReq_2.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176612_1
        }

        /*1-3-13查本次修订就职记录列表[166]   */
        Assert.isNull(queryInductionRecordListReq_2.getOrganizationId(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-组织ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq_2.getBatchId(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-批次ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq_2.getUpdateStatus(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-批次下更新状态不能为空", false);
        Assert.isNull(queryInductionRecordListReq_2.getSpaceId(), "D1-3撤销就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-创建于空间ID不能为空", false);
        listInductionRecord_5 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_2);


//步骤7: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN_3;
        if (listInductionRecord_5 != null && !CollectionUtil.isEmpty(listInductionRecord_5) && listInductionRecord_5.size() > 0) {
            List<InductionRecord> listInductionRecord_7 = new ArrayList<>();
            if (listInductionRecord_5 != null && !CollectionUtil.isEmpty(listInductionRecord_5) && listInductionRecord_5 != null && !CollectionUtil.isEmpty(listInductionRecord_5)) {
                listInductionRecord_7 = listInductionRecord_5.stream().map(item -> {
                    InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                    elm.setIsUpdate("FALSE");
                    elm.setUpdateStatus("UNCHANGED");

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:176616_1
            }

            /*1-3-13批量改就职记录（重置本次修订）[1647]   */

            bOOLEAN_3 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_7);


        }

//步骤8: M-Redis批量清空用户信息（特殊方法） - batchClearUserInfoFromRedis
        //ModelCode: batchClearUserInfoFromRedis
        BatchClearUserInfoFromRedisRespDto batchClearUserInfoFromRedisRes = null;
        if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord.size() > 0) {
            BatchClearUserInfoFromRedisReqDto batchClearUserInfoFromRedisReq = new BatchClearUserInfoFromRedisReqDto();
            batchClearUserInfoFromRedisReq.setBeginMemberList(listInductionRecord.stream().map(item -> item.getOriginalRoleMemberId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:215633_1

            /*M-Redis批量清空用户信息（特殊方法）[1695]  入参身份ID数据集，清除用户就职信息缓存 */

            batchClearUserInfoFromRedisRes = nbBatch.batchClearUserInfoFromRedis(batchClearUserInfoFromRedisReq);


        }

//步骤9: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
        RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
        RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto = new RefreshMemberBatchProgressComReqDto();
        refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(Long.valueOf(20));//CUSTOM_CONVENTION//sourceId:284704_1
        refreshMemberBatchProgressComReqDto.setBatchHandleStep("1");//CUSTOM_CONVENTION//sourceId:284705_1
        refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_DELETE_BATCH");//sourceId:284706_1
        refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318742_1
        refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318743_1
        refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318744_1
        if (reqDto != null) {
            refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:284709_1
        }

        /*D1-3更新组织架构成员批次处理进度20(公共)[3723]   */
        Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(), "D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-组织ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(), "D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理进度不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(), "D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理步骤不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(), "D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理类型不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(), "D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(), "D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建于空间ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(), "D1-3撤销就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建于联盟应用ID不能为空", false);
        refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto);


        UndoInductionRecordBatchProcessingComRespDto retData = new UndoInductionRecordBatchProcessingComRespDto();


        return retData;
    }

    /**
     * D1-3发布就职记录相关批次处理(公共)[3724]
     * gen by moon at 12/25/2023, 1:30:44 AM
     */
    @Trace(operationName = "D1-3发布就职记录相关批次处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReleaseInductionRecordBatchProcessingComRespDto releaseInductionRecordBatchProcessingCom(ReleaseInductionRecordBatchProcessingComReqDto reqDto) {


        //步骤0: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
        queryInductionRecordListReq.setUpdateStatus("NEW");//sourceId:177081_1
        queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:177082_1
        if (reqDto != null) {
            queryInductionRecordListReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:177079_1
            queryInductionRecordListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:177080_1
        }

        /*1-3-13查本次新增就职记录列表[166]   */
        Assert.isNull(queryInductionRecordListReq.getOrganizationId(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-组织ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getBatchId(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-批次ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getUpdateStatus(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-批次下更新状态不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSpaceId(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次新增就职记录列表-创建于空间ID不能为空", false);
        listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN;
        if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord.size() > 0) {
            List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
            if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord)) {
                listInductionRecord_2 = listInductionRecord.stream().map(item -> {
                    InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                    elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME
                    elm.setSubjectLifeCycle("CURRENTLY_VALID");
                    elm.setIsEditing("FALSE");
                    elm.setIsUpdate("FALSE");
                    elm.setUpdateStatus("UNCHANGED");

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:177086_1
            }

            /*1-3-13批量改就职记录为当前有效[1647]   */

            bOOLEAN = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_2)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤2: D1-执行批次新增编制处理(公共) - implementBatchStaffingCreateCom
        ImplementBatchStaffingCreateComRespDto implementBatchStaffingCreateComRespDto = null;
        if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord.size() > 0) {
            ImplementBatchStaffingCreateComReqDto implementBatchStaffingCreateComReqDto = new ImplementBatchStaffingCreateComReqDto();
            if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord)) {
                implementBatchStaffingCreateComReqDto.setStaffingList(listInductionRecord.stream().map(item -> item.getStaffingId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:259807_1
            }

            /*D1-执行批次新增编制处理(公共)[4204]   */

            implementBatchStaffingCreateComRespDto = staffingService.implementBatchStaffingCreateCom(implementBatchStaffingCreateComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤3: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord_3 = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq_1 = new QueryInductionRecordListReq();
        queryInductionRecordListReq_1.setUpdateStatus("ARCHIVE");//sourceId:177110_1
        queryInductionRecordListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:177111_1
        if (reqDto != null) {
            queryInductionRecordListReq_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:177108_1
        }

        /*1-3-13查本次存档就职记录列表[166]   */
        Assert.isNull(queryInductionRecordListReq_1.getOrganizationId(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-组织ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq_1.getUpdateStatus(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-批次下更新状态不能为空", false);
        Assert.isNull(queryInductionRecordListReq_1.getSpaceId(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次存档就职记录列表-创建于空间ID不能为空", false);
        listInductionRecord_3 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1)/*vcase invoke 本地 method 方法调用;*/;


//步骤4: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN_1;
        if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3.size() > 0) {
            List<InductionRecord> listInductionRecord_5 = new ArrayList<>();
            if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3)) {
                listInductionRecord_5 = listInductionRecord_3.stream().map(item -> {
                    InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                    elm.setBatchEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME
                    elm.setSubjectLifeCycle("ARCHIVING");
                    elm.setIsArchive("TRUE");
                    elm.setArchivngType("ARCHIVED");
                    elm.setIsUpdate("FALSE");
                    elm.setUpdateStatus("ARCHIVE");

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:177115_1
            }

            /*1-3-13批量改就职记录为历史存档[1647]   */

            bOOLEAN_1 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_5)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤5: D1-执行批次存档编制处理(公共) - implementBatchStaffingArchiveCom
        ImplementBatchStaffingArchiveComRespDto implementBatchStaffingArchiveComRespDto = null;
        if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3.size() > 0) {
            ImplementBatchStaffingArchiveComReqDto implementBatchStaffingArchiveComReqDto = new ImplementBatchStaffingArchiveComReqDto();
            if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3)) {
                implementBatchStaffingArchiveComReqDto.setStaffingList(listInductionRecord_3.stream().map(item -> item.getStaffingId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:259814_1
            }

            /*D1-执行批次存档编制处理(公共)[4205]   */

            implementBatchStaffingArchiveComRespDto = staffingService.implementBatchStaffingArchiveCom(implementBatchStaffingArchiveComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤6: D1-2执行权限更新状态(公共) - implementPowerUpdateStatusCom
        ImplementPowerUpdateStatusComRespDto implementPowerUpdateStatusComRespDto = null;
        if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3.size() > 0) {
            ImplementPowerUpdateStatusComReqDto implementPowerUpdateStatusComReqDto = new ImplementPowerUpdateStatusComReqDto();
            implementPowerUpdateStatusComReqDto.setTypeCode("PERSONAL_DEPARTMENT");//sourceId:178271_1
            if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3)) {
                implementPowerUpdateStatusComReqDto.setTributPowerList(listInductionRecord_3.stream().map(item -> item.getInductionRecordId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:178270_1
            }

            /*D1-2执行权限更新状态(公共)[3762]   */
            Assert.isNull(implementPowerUpdateStatusComReqDto.getTypeCode(), "D1-3发布就职记录相关批次处理(公共)-D1-2执行权限更新状态(公共)-分配对象类型编码不能为空", false);
            implementPowerUpdateStatusComRespDto = powerService.implementPowerUpdateStatusCom(implementPowerUpdateStatusComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤7: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord_6 = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq_2 = new QueryInductionRecordListReq();
        queryInductionRecordListReq_2.setUpdateStatus("REVISION");//sourceId:177118_1
        queryInductionRecordListReq_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:177119_1
        if (reqDto != null) {
            queryInductionRecordListReq_2.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:177116_1
        }

        /*1-3-13查本次修订就职记录列表[166]   */
        Assert.isNull(queryInductionRecordListReq_2.getOrganizationId(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-组织ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq_2.getUpdateStatus(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-批次下更新状态不能为空", false);
        Assert.isNull(queryInductionRecordListReq_2.getSpaceId(), "D1-3发布就职记录相关批次处理(公共)-1-3-13查本次修订就职记录列表-创建于空间ID不能为空", false);
        listInductionRecord_6 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_2)/*vcase invoke 本地 method 方法调用;*/;


//步骤8: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN_2;
        if (listInductionRecord_6 != null && !CollectionUtil.isEmpty(listInductionRecord_6) && listInductionRecord_6.size() > 0) {
            List<InductionRecord> listInductionRecord_8 = new ArrayList<>();
            if (listInductionRecord_6 != null && !CollectionUtil.isEmpty(listInductionRecord_6) && listInductionRecord_6 != null && !CollectionUtil.isEmpty(listInductionRecord_6)) {
                listInductionRecord_8 = listInductionRecord_6.stream().map(item -> {
                    InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                    elm.setIsUpdate("FALSE");
                    elm.setUpdateStatus("UNCHANGED");

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:177121_1
            }

            /*1-3-13批量改就职记录（重置本次修订）[1647]   */

            bOOLEAN_2 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_8)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤9: D1执行批次发布部门职务处理(公共) - implementBatchFileDeptPositionHandleCom
        ImplementBatchFileDeptPositionHandleComRespDto implementBatchFileDeptPositionHandleComRespDto = null;
        ImplementBatchFileDeptPositionHandleComReqDto implementBatchFileDeptPositionHandleComReqDto = new ImplementBatchFileDeptPositionHandleComReqDto();
        if (reqDto != null) {
            implementBatchFileDeptPositionHandleComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:178787_1
        }

        /*D1执行批次发布部门职务处理(公共)[3765]   */
        Assert.isNull(implementBatchFileDeptPositionHandleComReqDto.getOrganizationId(), "D1-3发布就职记录相关批次处理(公共)-D1执行批次发布部门职务处理(公共)-组织ID不能为空", false);
        implementBatchFileDeptPositionHandleComRespDto = orgPositionService.implementBatchFileDeptPositionHandleCom(implementBatchFileDeptPositionHandleComReqDto)/*vcase invoke isSameApp*/;


//步骤10: M-Redis批量清空用户信息（特殊方法） - batchClearUserInfoFromRedis
        //ModelCode: batchClearUserInfoFromRedis
        BatchClearUserInfoFromRedisRespDto batchClearUserInfoFromRedisRes = null;
        if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3.size() > 0) {
            BatchClearUserInfoFromRedisReqDto batchClearUserInfoFromRedisReq = new BatchClearUserInfoFromRedisReqDto();
            if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3)) {
                batchClearUserInfoFromRedisReq.setBeginMemberList(listInductionRecord_3.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:178273_1
            }

            /*M-Redis批量清空用户信息（特殊方法）[1695]  入参身份ID数据集，清除用户就职信息缓存 */

            batchClearUserInfoFromRedisRes = nbBatch.batchClearUserInfoFromRedis(batchClearUserInfoFromRedisReq);


        }

//步骤11: D1执行循环部门群成员通道关系处理(公共) - implementLoopDeptGroupMemberChannelExitProcessCom
        ImplementLoopDeptGroupMemberChannelExitProcessComRespDto implementLoopDeptGroupMemberChannelExitProcessComRespDto = null;
        if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord.size() > 0) {
            ImplementLoopDeptGroupMemberChannelExitProcessComReqDto implementLoopDeptGroupMemberChannelExitProcessComReqDto = new ImplementLoopDeptGroupMemberChannelExitProcessComReqDto();
            implementLoopDeptGroupMemberChannelExitProcessComReqDto.setMessageLocationCode("WORK_CIRCLE");//CUSTOM_CONVENTION//sourceId:1443282_1
            implementLoopDeptGroupMemberChannelExitProcessComReqDto.setBorcScene("TOB_SCENE");//sourceId:1443283_1
            if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord)) {
                implementLoopDeptGroupMemberChannelExitProcessComReqDto.setNewInductionRecordList(listInductionRecord.stream().map(item -> BeanUtil.toBean(item, NewInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1443280_1
            }
            if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3)) {
                implementLoopDeptGroupMemberChannelExitProcessComReqDto.setOldInductionRecordList(listInductionRecord_3.stream().map(item -> BeanUtil.toBean(item, OldInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1443281_1
            }

            /*D1执行循环部门群成员通道关系处理(公共)[8198]   */
            Assert.isNull(implementLoopDeptGroupMemberChannelExitProcessComReqDto.getMessageLocationCode(), "D1-3发布就职记录相关批次处理(公共)-D1执行循环部门群成员通道关系处理(公共)-消息位置标识不能为空", false);
            Assert.isNull(implementLoopDeptGroupMemberChannelExitProcessComReqDto.getBorcScene(), "D1-3发布就职记录相关批次处理(公共)-D1执行循环部门群成员通道关系处理(公共)-toB或toC场景不能为空", false);
            implementLoopDeptGroupMemberChannelExitProcessComRespDto = memberService.implementLoopDeptGroupMemberChannelExitProcessCom(implementLoopDeptGroupMemberChannelExitProcessComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤12: D1执行组织群成员通道关系处理(公共) - implementOrgGroupMemberChannelExitProcessCom
        ImplementOrgGroupMemberChannelExitProcessComRespDto implementOrgGroupMemberChannelExitProcessComRespDto = null;
        if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord.size() > 0) {
            ImplementOrgGroupMemberChannelExitProcessComReqDto implementOrgGroupMemberChannelExitProcessComReqDto = new ImplementOrgGroupMemberChannelExitProcessComReqDto();
            implementOrgGroupMemberChannelExitProcessComReqDto.setMessageLocationCode("WORK_CIRCLE");//CUSTOM_CONVENTION//sourceId:1443337_1
            implementOrgGroupMemberChannelExitProcessComReqDto.setBorcScene("TOB_SCENE");//sourceId:1443338_1
            if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord)) {
                implementOrgGroupMemberChannelExitProcessComReqDto.setNewInductionRecordList(listInductionRecord.stream().map(item -> BeanUtil.toBean(item, NewInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1443335_1
            }
            if (listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3) && listInductionRecord_3 != null && !CollectionUtil.isEmpty(listInductionRecord_3)) {
                implementOrgGroupMemberChannelExitProcessComReqDto.setOldInductionRecordList(listInductionRecord_3.stream().map(item -> BeanUtil.toBean(item, OldInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1443336_1
            }

            /*D1执行组织群成员通道关系处理(公共)[8199]   */
            Assert.isNull(implementOrgGroupMemberChannelExitProcessComReqDto.getMessageLocationCode(), "D1-3发布就职记录相关批次处理(公共)-D1执行组织群成员通道关系处理(公共)-消息位置标识不能为空", false);
            Assert.isNull(implementOrgGroupMemberChannelExitProcessComReqDto.getBorcScene(), "D1-3发布就职记录相关批次处理(公共)-D1执行组织群成员通道关系处理(公共)-toB或toC场景不能为空", false);
            implementOrgGroupMemberChannelExitProcessComRespDto = memberService.implementOrgGroupMemberChannelExitProcessCom(implementOrgGroupMemberChannelExitProcessComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤13: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
        RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
        RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto = new RefreshMemberBatchProgressComReqDto();
        refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(Long.valueOf(20));//CUSTOM_CONVENTION//sourceId:284698_1
        refreshMemberBatchProgressComReqDto.setBatchHandleStep("1");//CUSTOM_CONVENTION//sourceId:284699_1
        refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_BATCH_PUBLISH");//sourceId:284700_1
        refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318739_1
        refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318740_1
        refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318741_1
        if (reqDto != null) {
            refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:284703_1
        }

        /*D1-3更新组织架构成员批次处理进度20(公共)[3723]   */
        Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(), "D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-组织ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(), "D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理进度不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(), "D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-处理步骤不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(), "D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-批次处理类型不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(), "D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(), "D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建于空间ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(), "D1-3发布就职记录相关批次处理(公共)-D1-3更新组织架构成员批次处理进度20(公共)-创建于联盟应用ID不能为空", false);
        refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto)/*vcase invoke 同服务,同domain*/;


        ReleaseInductionRecordBatchProcessingComRespDto retData = new ReleaseInductionRecordBatchProcessingComRespDto();


        return retData;
    }

    /**
     * D1-3更新组织架构成员批次处理进度(公共)[3723]
     * gen by moon at 9/20/2023, 11:29:46 PM
     */
    @Trace(operationName = "D1-3更新组织架构成员批次处理进度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressCom(RefreshMemberBatchProgressComReqDto reqDto) {


        //virtualUsage M1执行【异步开始】  11193
        //ModelCode: asynchronizationStart
        Callable<String> call = new Callable<String>() {

            @Override
            public String call() throws Exception {
                //执行方法
//virtualUsage M1执行底层框架公共字段推送内存（特殊方法）  16099
                //ModelCode: publicFieldCache
                ImplementBottomPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
                ImplementBottomPublicFieldPushMemoryReqDto publicFieldCacheReq = new ImplementBottomPublicFieldPushMemoryReqDto();
                if (reqDto != null) {
                    publicFieldCacheReq.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:318717_1_16099
                    publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:318718_1_16099
                    publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:318719_1_16099
                }

                /*M1执行底层框架公共字段推送内存（特殊方法）[4519]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
                Assert.isNull(publicFieldCacheReq.getCreateInductionId(), "D1-3更新组织架构成员批次处理进度(公共)-M1执行底层框架公共字段推送内存（特殊方法）-创建人就职记录ID 不能为空", false);
                Assert.isNull(publicFieldCacheReq.getSpaceId(), "D1-3更新组织架构成员批次处理进度(公共)-M1执行底层框架公共字段推送内存（特殊方法）-创建于空间ID不能为空", false);
                Assert.isNull(publicFieldCacheReq.getAppId(), "D1-3更新组织架构成员批次处理进度(公共)-M1执行底层框架公共字段推送内存（特殊方法）-创建于联盟应用ID不能为空", false);
                publicFieldCacheRes = nbBatch.implementBottomPublicFieldPushMemory(publicFieldCacheReq);


//virtualUsage M1-获取接收字段（特殊方法）  11233
                //ModelCode: receptionService
                QueryReceiveFieldDetailRespDto receptionServiceRes = null;
                QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
                if (reqDto != null) {
                    receptionServiceReq.setBatchHandleSpeed(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173234_1_11233
                    receptionServiceReq.setBatchHandleStep(reqDto.getBatchHandleStep());//SimpleFieldAssign//sourceId:173233_1_11233
                    receptionServiceReq.setBatchHandleTypeCod(reqDto.getBatchHandleTypeCod());//SimpleFieldAssign//sourceId:173237_1_11233
                }

                /*M1-获取接收字段（特殊方法）[3715]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getBatchHandleSpeed(), "D1-3更新组织架构成员批次处理进度(公共)-M1-获取接收字段（特殊方法）-批次处理进度不能为空", false);
                Assert.isNull(receptionServiceReq.getBatchHandleStep(), "D1-3更新组织架构成员批次处理进度(公共)-M1-获取接收字段（特殊方法）-处理步骤不能为空", false);
                Assert.isNull(receptionServiceReq.getBatchHandleTypeCod(), "D1-3更新组织架构成员批次处理进度(公共)-M1-获取接收字段（特殊方法）-批次处理类型不能为空", false);
                receptionServiceRes = nbBatch.queryReceiveFieldDetail(receptionServiceReq);


//virtualUsage 1-3-12查询组织详情  15250
                Organization organization = null;
                QueryOrgDetailReq queryOrgDetailReq = new QueryOrgDetailReq();
                queryOrgDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:281993_1_15250
                if (reqDto != null) {
                    queryOrgDetailReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:281986_1_15250
                }

                /*1-3-12查询组织详情[201]   */
                Assert.isNull(queryOrgDetailReq.getOrganizationId(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12查询组织详情-组织ID不能为空", false);
                organization = mOrganizationService.queryOrgDetail(queryOrgDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((reqDto != null && reqDto.getBatchHandleStep() != null && reqDto.getBatchHandleStep().equals("0") && organization != null && organization.getDelBatchIsDone() != null && organization.getDelBatchIsDone().equals("FALSE")) && (reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH") || reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH"))) {
                    //if((D1-3更新组织架构成员批次处理进度(公共).批次处理步骤 等于 0 and 1-3-12查询组织详情.批次处理是否完成 等于 否) and (D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销))  11267

                    Organization organization_2 = null;
                    ImplementSpinLockCheckOrgReq implementSpinLockCheckOrgReq = new ImplementSpinLockCheckOrgReq();
                    implementSpinLockCheckOrgReq.setBatchProcessProgress(Long.valueOf(-1));//CUSTOM_CONVENTION//sourceId:281937_1_15246
                    if (reqDto != null) {
                        implementSpinLockCheckOrgReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279420_1_15246
                    }

                    /*1-3-12执行悬停查组织（悬停-1）[4304]   */
                    Assert.isNull(implementSpinLockCheckOrgReq.getOrganizationId(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停-1）-组织ID不能为空", false);
                    Assert.isNull(implementSpinLockCheckOrgReq.getBatchProcessProgress(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停-1）-批次处理进度不能为空", false);
                    organization_2 = mOrganizationService.implementSpinLockCheckOrg(implementSpinLockCheckOrgReq)/*vcase invoke 本地 method 方法调用;*/;
                    Assert.isTrue(organization_2 == null || organization_2.getOrganizationId() == null, "找不到数据，系统异常", false);


                    boolean bOOLEAN;
                    Organization organization_4 = new Organization();
                    if (reqDto != null) {
                        organization_4.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:173155_1_11268
                        organization_4.setBatchProcessProgress(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173994_1_11268
                    }

                    /*1-3-12初始化组织架构批次相关设置[197]   */
                    Assert.isNull(organization_4.getOrganizationId(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12初始化组织架构批次相关设置-组织ID不能为空", false);
                    Assert.isNull(organization_4.getBatchProcessProgress(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12初始化组织架构批次相关设置-批次处理进度不能为空", false);
                    bOOLEAN = mOrganizationService.updateOrg(organization_4)/*vcase invoke 本地 method 方法调用;*/;


//processBranchName:正常结束 ,processBranchId:11269

                } else if ((reqDto != null && reqDto.getBatchHandleStep() != null && reqDto.getBatchHandleStep().equals("1") && organization != null && organization.getDelBatchIsDone() != null && organization.getDelBatchIsDone().equals("FALSE")) && (reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH") || reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH"))) {
                    //elseif((D1-3更新组织架构成员批次处理进度(公共).批次处理步骤 等于 1 and 1-3-12查询组织详情.批次处理是否完成 等于 否) and (D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销))  11279

                    Organization organization_5 = null;
                    ImplementSpinLockCheckOrgReq implementSpinLockCheckOrgReq_1 = new ImplementSpinLockCheckOrgReq();
                    implementSpinLockCheckOrgReq_1.setBatchProcessProgress(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:281967_1_15251
                    if (reqDto != null) {
                        implementSpinLockCheckOrgReq_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:281961_1_15251
                    }

                    /*1-3-12执行悬停查组织（悬停0）[4304]   */
                    Assert.isNull(implementSpinLockCheckOrgReq_1.getOrganizationId(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停0）-组织ID不能为空", false);
                    Assert.isNull(implementSpinLockCheckOrgReq_1.getBatchProcessProgress(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停0）-批次处理进度不能为空", false);
                    organization_5 = mOrganizationService.implementSpinLockCheckOrg(implementSpinLockCheckOrgReq_1)/*vcase invoke 本地 method 方法调用;*/;
                    Assert.isTrue(organization_5 == null || organization_5.getOrganizationId() == null, "找不到数据，系统异常", false);


                    boolean bOOLEAN_1;
                    Organization organization_7 = new Organization();
                    if (reqDto != null) {
                        organization_7.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:173174_1_11280
                        organization_7.setBatchProcessProgress(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173996_1_11280
                    }

                    /*1-3-12更新组织架构设置进度[197]   */
                    Assert.isNull(organization_7.getOrganizationId(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构设置进度-组织ID不能为空", false);
                    Assert.isNull(organization_7.getBatchProcessProgress(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构设置进度-批次处理进度不能为空", false);
                    bOOLEAN_1 = mOrganizationService.updateOrg(organization_7)/*vcase invoke 本地 method 方法调用;*/;


//processBranchName:正常结束 ,processBranchId:11281

                } else if ((reqDto != null && reqDto.getBatchHandleStep() != null && reqDto.getBatchHandleStep().equals("2") && organization != null && organization.getDelBatchIsDone() != null && organization.getDelBatchIsDone().equals("FALSE")) && (reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH") || reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH"))) {
                    //elseif((D1-3更新组织架构成员批次处理进度(公共).批次处理步骤 等于 2 and 1-3-12查询组织详情.批次处理是否完成 等于 否) and (D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销))  11283

                    Organization organization_8 = null;
                    ImplementSpinLockCheckOrgReq implementSpinLockCheckOrgReq_2 = new ImplementSpinLockCheckOrgReq();
                    implementSpinLockCheckOrgReq_2.setBatchProcessProgress(Long.valueOf(20));//CUSTOM_CONVENTION//sourceId:281974_1_15252
                    if (reqDto != null) {
                        implementSpinLockCheckOrgReq_2.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:281968_1_15252
                    }

                    /*1-3-12执行悬停查组织（悬停20）[4304]   */
                    Assert.isNull(implementSpinLockCheckOrgReq_2.getOrganizationId(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停20）-组织ID不能为空", false);
                    Assert.isNull(implementSpinLockCheckOrgReq_2.getBatchProcessProgress(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停20）-批次处理进度不能为空", false);
                    organization_8 = mOrganizationService.implementSpinLockCheckOrg(implementSpinLockCheckOrgReq_2)/*vcase invoke 本地 method 方法调用;*/;


                    boolean bOOLEAN_2;
                    Organization organization_10 = new Organization();
                    if (reqDto != null) {
                        organization_10.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:173174_1_11284
                        organization_10.setBatchProcessProgress(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173996_1_11284
                    }

                    /*1-3-12更新组织架构设置进度[197]   */
                    Assert.isNull(organization_10.getOrganizationId(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构设置进度-组织ID不能为空", false);
                    Assert.isNull(organization_10.getBatchProcessProgress(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构设置进度-批次处理进度不能为空", false);
                    bOOLEAN_2 = mOrganizationService.updateOrg(organization_10)/*vcase invoke 本地 method 方法调用;*/;


//processBranchName:正常结束 ,processBranchId:11288

                } else if ((reqDto != null && reqDto.getBatchHandleStep() != null && reqDto.getBatchHandleStep().equals("100") && organization != null && organization.getDelBatchIsDone() != null && organization.getDelBatchIsDone().equals("FALSE")) && (reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH") || reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH"))) {
                    //elseif((D1-3更新组织架构成员批次处理进度(公共).批次处理步骤 等于 100 and 1-3-12查询组织详情.批次处理是否完成 等于 否) and (D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销))  11285

                    Organization organization_11 = null;
                    ImplementSpinLockCheckOrgReq implementSpinLockCheckOrgReq_3 = new ImplementSpinLockCheckOrgReq();
                    implementSpinLockCheckOrgReq_3.setBatchProcessProgress(Long.valueOf(80));//CUSTOM_CONVENTION//sourceId:281985_1_15253
                    if (reqDto != null) {
                        implementSpinLockCheckOrgReq_3.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:281979_1_15253
                    }

                    /*1-3-12执行悬停查组织（悬停80）[4304]   */
                    Assert.isNull(implementSpinLockCheckOrgReq_3.getOrganizationId(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停80）-组织ID不能为空", false);
                    Assert.isNull(implementSpinLockCheckOrgReq_3.getBatchProcessProgress(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12执行悬停查组织（悬停80）-批次处理进度不能为空", false);
                    organization_11 = mOrganizationService.implementSpinLockCheckOrg(implementSpinLockCheckOrgReq_3)/*vcase invoke 本地 method 方法调用;*/;


                    boolean bOOLEAN_3;
                    Organization organization_13 = new Organization();
                    organization_13.setDelBatchIsDone("TRUE");//sourceId:173998_1_11286
                    if (reqDto != null) {
                        organization_13.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:173188_1_11286
                        organization_13.setBatchProcessProgress(reqDto.getBatchHandleSpeed());//SimpleFieldAssign//sourceId:173997_1_11286
                    }

                    /*1-3-12更新组织架构批次处理完成[197]   */
                    Assert.isNull(organization_13.getOrganizationId(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构批次处理完成-组织ID不能为空", false);
                    Assert.isNull(organization_13.getBatchProcessProgress(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构批次处理完成-批次处理进度不能为空", false);
                    Assert.isNull(organization_13.getDelBatchIsDone(), "D1-3更新组织架构成员批次处理进度(公共)-1-3-12更新组织架构批次处理完成-批次处理是否完成不能为空", false);
                    bOOLEAN_3 = mOrganizationService.updateOrg(organization_13)/*vcase invoke 本地 method 方法调用;*/;


//processBranchName:正常结束 ,processBranchId:11287

                } else if ((reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_BATCH_PUBLISH") || reqDto != null && reqDto.getBatchHandleTypeCod() != null && reqDto.getBatchHandleTypeCod().equals("ORG_DELETE_BATCH")) && (organization != null && organization.getDelBatchIsDone() != null && organization.getDelBatchIsDone().equals("0"))) {
                    //elseif((D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次发布 or D1-3更新组织架构成员批次处理进度(公共).批次处理类型 等于 组织架构批次撤销) and 1-3-12查询组织详情.批次处理是否完成 等于 --请选择--是)  11291

//异常结束 11294
                    throw new BizException("10300051", "对不起，组织架构成员修订的批次已经处理完成，不可重复操作！", false);
                }
//virtualUsage M1执行【异步结束】  11194
                //ModelCode: asynchronizationEnd
                return "";
            }
        };
        CommonFunctionHelper.asynExcute(call);
        RefreshMemberBatchProgressComRespDto retData = new RefreshMemberBatchProgressComRespDto();


        return retData;
    }

    /**
     * D1执行组织架构批次发布[3721]
     * gen by moon at 9/20/2023, 11:57:54 PM
     */
    @Trace(operationName = "D1执行组织架构批次发布")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementOrgBatchPublishRespDto implementOrgBatchPublish(ImplementOrgBatchPublishReqDto reqDto) {


        //步骤0: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
        RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
        RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto = new RefreshMemberBatchProgressComReqDto();
        refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_BATCH_PUBLISH");//sourceId:174087_1
        refreshMemberBatchProgressComReqDto.setBatchHandleStep("0");//CUSTOM_CONVENTION//sourceId:174086_1
        refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:264449_1
        refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318723_1
        refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318724_1
        refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318725_1
        if (reqDto != null) {
            refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279564_1
        }

        /*D1-3更新组织架构成员批次处理进度0(公共)[3723]   */
        Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-组织ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-批次处理类型不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-处理步骤不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-批次处理进度不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-创建于空间ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度0(公共)-创建于联盟应用ID不能为空", false);
        refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤1: D1-3发布就职记录相关批次处理(公共) - releaseInductionRecordBatchProcessingCom
        ReleaseInductionRecordBatchProcessingComRespDto releaseInductionRecordBatchProcessingComRespDto = null;
        ReleaseInductionRecordBatchProcessingComReqDto releaseInductionRecordBatchProcessingComReqDto = new ReleaseInductionRecordBatchProcessingComReqDto();
        if (reqDto != null) {
            releaseInductionRecordBatchProcessingComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:179057_1
            releaseInductionRecordBatchProcessingComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:179058_1
        }

        /*D1-3发布就职记录相关批次处理(公共)[3724]   */
        Assert.isNull(releaseInductionRecordBatchProcessingComReqDto.getOrganizationId(), "D1执行组织架构批次发布-D1-3发布就职记录相关批次处理(公共)-组织ID不能为空", false);
        Assert.isNull(releaseInductionRecordBatchProcessingComReqDto.getBatchId(), "D1执行组织架构批次发布-D1-3发布就职记录相关批次处理(公共)-批次ID不能为空", false);
        releaseInductionRecordBatchProcessingComRespDto = releaseInductionRecordBatchProcessingCom(releaseInductionRecordBatchProcessingComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤2: D1-1发布组织架构成员基础批次处理(公共) - releaseOrgBaseBatchProcessingCom
        ReleaseOrgBaseBatchProcessingComRespDto releaseOrgBaseBatchProcessingComRespDto = null;
        ReleaseOrgBaseBatchProcessingComReqDto releaseOrgBaseBatchProcessingComReqDto = new ReleaseOrgBaseBatchProcessingComReqDto();
        if (reqDto != null) {
            releaseOrgBaseBatchProcessingComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279727_1
            releaseOrgBaseBatchProcessingComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176147_1
        }

        /*D1-1发布组织架构成员基础批次处理(公共)[3726]   */
        Assert.isNull(releaseOrgBaseBatchProcessingComReqDto.getOrganizationId(), "D1执行组织架构批次发布-D1-1发布组织架构成员基础批次处理(公共)-组织ID不能为空", false);
        Assert.isNull(releaseOrgBaseBatchProcessingComReqDto.getBatchId(), "D1执行组织架构批次发布-D1-1发布组织架构成员基础批次处理(公共)-批次ID不能为空", false);
        releaseOrgBaseBatchProcessingComRespDto = releaseOrgBaseBatchProcessingCom(releaseOrgBaseBatchProcessingComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤3: 1-3-12修改组织 - updateOrg
        boolean bOOLEAN;
        Organization organization = new Organization();
        organization.setCurrentManageObjectType("UNMANNED_MGT");//sourceId:304394_1
        organization.setManageLockStatus("AUTO_LOCK");//sourceId:304389_1
        organization.setReasonOfManageLock("组织架构成员已确认设置完成，锁定停止维护。");//CUSTOM_CONVENTION//sourceId:304390_1
        organization.setUsingLockStatus("UNLOCK");//sourceId:304392_1
        organization.setReasonOfUsingLock("---");//NULL//sourceId:304391_1
        if (reqDto != null) {
            organization.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:304386_1
        }

        /*1-3-12修改组织锁定状态等[197]   */
        Assert.isNull(organization.getOrganizationId(), "D1执行组织架构批次发布-1-3-12修改组织锁定状态等-组织ID不能为空", false);
        Assert.isNull(organization.getCurrentManageObjectType(), "D1执行组织架构批次发布-1-3-12修改组织锁定状态等-当前管理对象类型不能为空", false);
        Assert.isNull(organization.getManageLockStatus(), "D1执行组织架构批次发布-1-3-12修改组织锁定状态等-管理锁定状态不能为空", false);
        Assert.isNull(organization.getReasonOfManageLock(), "D1执行组织架构批次发布-1-3-12修改组织锁定状态等-管理锁定原因不能为空", false);
        Assert.isNull(organization.getUsingLockStatus(), "D1执行组织架构批次发布-1-3-12修改组织锁定状态等-使用锁定状态不能为空", false);
        Assert.isNull(organization.getReasonOfUsingLock(), "D1执行组织架构批次发布-1-3-12修改组织锁定状态等-使用锁定原因不能为空", false);
        bOOLEAN = mOrganizationService.updateOrg(organization)/*vcase invoke 本地 method 方法调用;*/;


//步骤4: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
        RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto_1 = null;
        RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto_1 = new RefreshMemberBatchProgressComReqDto();
        refreshMemberBatchProgressComReqDto_1.setBatchHandleSpeed(Long.valueOf(100));//CUSTOM_CONVENTION//sourceId:264450_1
        refreshMemberBatchProgressComReqDto_1.setBatchHandleStep("100");//CUSTOM_CONVENTION//sourceId:175433_1
        refreshMemberBatchProgressComReqDto_1.setBatchHandleTypeCod("ORG_BATCH_PUBLISH");//sourceId:175434_1
        refreshMemberBatchProgressComReqDto_1.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318728_1
        refreshMemberBatchProgressComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318729_1
        refreshMemberBatchProgressComReqDto_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318730_1
        if (reqDto != null) {
            refreshMemberBatchProgressComReqDto_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279565_1
        }

        /*D1-3更新组织架构成员批次处理进度100(公共)[3723]   */
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getOrganizationId(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-组织ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleSpeed(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-批次处理进度不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleStep(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-处理步骤不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleTypeCod(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-批次处理类型不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getCreateInductionId(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getSpaceId(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-创建于空间ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getAppId(), "D1执行组织架构批次发布-D1-3更新组织架构成员批次处理进度100(公共)-创建于联盟应用ID不能为空", false);
        refreshMemberBatchProgressComRespDto_1 = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto_1)/*vcase invoke 同服务,同domain*/;


//步骤5: D1-执行清理空间管理员临时就职记录(公共) - implementCleanSpaceAdminTtemporarynductionCom
        ImplementCleanSpaceAdminTtemporarynductionComRespDto implementCleanSpaceAdminTtemporarynductionComRespDto = null;
        ImplementCleanSpaceAdminTtemporarynductionComReqDto implementCleanSpaceAdminTtemporarynductionComReqDto = new ImplementCleanSpaceAdminTtemporarynductionComReqDto();
        if (reqDto != null) {
            implementCleanSpaceAdminTtemporarynductionComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:1128702_1
        }

        /*D1-执行清理空间管理员临时就职记录(公共)[7429]   */
        Assert.isNull(implementCleanSpaceAdminTtemporarynductionComReqDto.getOrganizationId(), "D1执行组织架构批次发布-D1-执行清理空间管理员临时就职记录(公共)-组织ID不能为空", false);
        implementCleanSpaceAdminTtemporarynductionComRespDto = inductionRecordService.implementCleanSpaceAdminTtemporarynductionCom(implementCleanSpaceAdminTtemporarynductionComReqDto)/*vcase invoke isSameApp*/;


        ImplementOrgBatchPublishRespDto retData = new ImplementOrgBatchPublishRespDto();


        return retData;
    }

    /**
     * D1执行组织架构撤销批次[3722]
     * gen by moon at 10/2/2022, 3:48:35 AM
     */
    @Trace(operationName = "D1执行组织架构撤销批次")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementOrgDeleteBatchRespDto implementOrgDeleteBatch(ImplementOrgDeleteBatchReqDto reqDto) {


        //步骤0: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
        RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto = null;
        RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto = new RefreshMemberBatchProgressComReqDto();
        refreshMemberBatchProgressComReqDto.setBatchHandleSpeed(0L);//CUSTOM_CONVENTION//sourceId:264451_1
        refreshMemberBatchProgressComReqDto.setBatchHandleStep("0");//CUSTOM_CONVENTION//sourceId:175437_1
        refreshMemberBatchProgressComReqDto.setBatchHandleTypeCod("ORG_DELETE_BATCH");//sourceId:175438_1
        refreshMemberBatchProgressComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318731_1
        refreshMemberBatchProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318733_1
        refreshMemberBatchProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318732_1
        if (reqDto != null) {
            refreshMemberBatchProgressComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279566_1
        }

        /*D1-3更新组织架构成员批次处理进度0(公共)[3723]   */
        Assert.isNull(refreshMemberBatchProgressComReqDto.getOrganizationId(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-组织ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleSpeed(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-批次处理进度不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleStep(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-批次处理步骤不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getBatchHandleTypeCod(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-批次处理类型不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getCreateInductionId(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getSpaceId(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-创建于空间ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto.getAppId(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度0(公共)-创建于联盟应用ID不能为空", false);
        refreshMemberBatchProgressComRespDto = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto);


//步骤1: D1-3撤销就职记录相关批次处理(公共) - undoInductionRecordBatchProcessingCom
        UndoInductionRecordBatchProcessingComRespDto undoInductionRecordBatchProcessingComRespDto = null;
        UndoInductionRecordBatchProcessingComReqDto undoInductionRecordBatchProcessingComReqDto = new UndoInductionRecordBatchProcessingComReqDto();
        if (reqDto != null) {
            undoInductionRecordBatchProcessingComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:176617_1
            undoInductionRecordBatchProcessingComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176618_1
        }

        /*D1-3撤销就职记录相关批次处理(公共)[3725]   */
        Assert.isNull(undoInductionRecordBatchProcessingComReqDto.getOrganizationId(), "D1执行组织架构撤销批次-D1-3撤销就职记录相关批次处理(公共)-组织ID不能为空", false);
        Assert.isNull(undoInductionRecordBatchProcessingComReqDto.getBatchId(), "D1执行组织架构撤销批次-D1-3撤销就职记录相关批次处理(公共)-批次ID不能为空", false);
        undoInductionRecordBatchProcessingComRespDto = undoInductionRecordBatchProcessingCom(undoInductionRecordBatchProcessingComReqDto);


//步骤2: D1-1撤销组织架构成员基础批次处理(公共) - undoOrgBaseBatchProcessingCom
        UndoOrgBaseBatchProcessingComRespDto undoOrgBaseBatchProcessingComRespDto = null;
        UndoOrgBaseBatchProcessingComReqDto undoOrgBaseBatchProcessingComReqDto = new UndoOrgBaseBatchProcessingComReqDto();
        if (reqDto != null) {
            undoOrgBaseBatchProcessingComReqDto.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279785_1
            undoOrgBaseBatchProcessingComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176149_1
        }

        /*D1-1撤销组织架构成员基础批次处理(公共)[3727]   */
        Assert.isNull(undoOrgBaseBatchProcessingComReqDto.getOrganizationId(), "D1执行组织架构撤销批次-D1-1撤销组织架构成员基础批次处理(公共)-组织ID不能为空", false);
        Assert.isNull(undoOrgBaseBatchProcessingComReqDto.getBatchId(), "D1执行组织架构撤销批次-D1-1撤销组织架构成员基础批次处理(公共)-批次ID不能为空", false);
        undoOrgBaseBatchProcessingComRespDto = undoOrgBaseBatchProcessingCom(undoOrgBaseBatchProcessingComReqDto);


//步骤3: 1-3-12修改组织 - updateOrg
        boolean bOOLEAN;
        Organization organization = new Organization();
        organization.setCurrentManageObjectType("UNMANNED_MGT");//sourceId:304405_1
        organization.setManageLockStatus("AUTO_LOCK");//sourceId:304400_1
        organization.setReasonOfManageLock("组织架构成员已确认设置完成，锁定停止维护。");//CUSTOM_CONVENTION//sourceId:304401_1
        organization.setUsingLockStatus("UNLOCK");//sourceId:304403_1
        organization.setReasonOfUsingLock("---");//NULL//sourceId:304402_1
        if (reqDto != null) {
            organization.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:304397_1
        }

        /*1-3-12修改组织锁定状态等[197]   */
        Assert.isNull(organization.getOrganizationId(), "D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-组织ID不能为空", false);
        Assert.isNull(organization.getCurrentManageObjectType(), "D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-当前管理对象类型不能为空", false);
        Assert.isNull(organization.getManageLockStatus(), "D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-管理锁定状态不能为空", false);
        Assert.isNull(organization.getReasonOfManageLock(), "D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-管理锁定原因不能为空", false);
        Assert.isNull(organization.getUsingLockStatus(), "D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-使用锁定状态不能为空", false);
        Assert.isNull(organization.getReasonOfUsingLock(), "D1执行组织架构撤销批次-1-3-12修改组织锁定状态等-使用锁定原因不能为空", false);
        bOOLEAN = mOrganizationService.updateOrg(organization);


//步骤4: D1-3更新组织架构成员批次处理进度(公共) - refreshMemberBatchProgressCom
        RefreshMemberBatchProgressComRespDto refreshMemberBatchProgressComRespDto_1 = null;
        RefreshMemberBatchProgressComReqDto refreshMemberBatchProgressComReqDto_1 = new RefreshMemberBatchProgressComReqDto();
        refreshMemberBatchProgressComReqDto_1.setBatchHandleSpeed(100L);//CUSTOM_CONVENTION//sourceId:175440_1
        refreshMemberBatchProgressComReqDto_1.setBatchHandleStep("100");//CUSTOM_CONVENTION//sourceId:175441_1
        refreshMemberBatchProgressComReqDto_1.setBatchHandleTypeCod("ORG_DELETE_BATCH");//sourceId:175442_1
        refreshMemberBatchProgressComReqDto_1.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:318736_1
        refreshMemberBatchProgressComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:318737_1
        refreshMemberBatchProgressComReqDto_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:318738_1
        if (reqDto != null) {
            refreshMemberBatchProgressComReqDto_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:279730_1
        }

        /*D1-3更新组织架构成员批次处理进度100(公共)[3723]   */
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getOrganizationId(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-组织ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleSpeed(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-批次处理进度不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleStep(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-批次处理步骤不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getBatchHandleTypeCod(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-批次处理类型不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getCreateInductionId(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getSpaceId(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-创建于空间ID不能为空", false);
        Assert.isNull(refreshMemberBatchProgressComReqDto_1.getAppId(), "D1执行组织架构撤销批次-D1-3更新组织架构成员批次处理进度100(公共)-创建于联盟应用ID不能为空", false);
        refreshMemberBatchProgressComRespDto_1 = refreshMemberBatchProgressCom(refreshMemberBatchProgressComReqDto_1);


        ImplementOrgDeleteBatchRespDto retData = new ImplementOrgDeleteBatchRespDto();


        return retData;
    }

    /**
     * D1-3判断发起组织批次操作可用(公共)[4150]
     * gen by moon at 10/1/2022, 11:50:54 PM
     */
    @Trace(operationName = "D1-3判断发起组织批次操作可用(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeInitiateOrgBatchUsableComRespDto judgeInitiateOrgBatchUsableCom(JudgeInitiateOrgBatchUsableComReqDto reqDto) {


        JudgeOrgOnlyPowerComRespDto judgeOrgOnlyPowerComRespDto_1 = null;
//virtualUsage 1-1-01查询是否有正在编辑的批次，避免重复  14072
        Batch batch = null;
        QueryBaseBatchDetailReq queryBaseBatchDetailReq = new QueryBaseBatchDetailReq();
        queryBaseBatchDetailReq.setPurposeTypeCode("ORG");//sourceId:246732_1_14072
        queryBaseBatchDetailReq.setSubjectLifeCycle("EDITING");//sourceId:246773_1_14072
        if (reqDto != null) {
            queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246733_1_14072
        }

        /*1-1-01查询是否有正在编辑的批次，避免重复[44]   */
        Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(), "D1-3判断发起组织批次操作可用(公共)-1-1-01查询是否有正在编辑的批次，避免重复-归属对象ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(), "D1-3判断发起组织批次操作可用(公共)-1-1-01查询是否有正在编辑的批次，避免重复-用途类型编码不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(), "D1-3判断发起组织批次操作可用(公共)-1-1-01查询是否有正在编辑的批次，避免重复-主体生命周期不能为空", false);
        batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);


        if ((batch == null)) {
            //if(1-1-01查询是否有正在编辑的批次，避免重复.出参 值等于空 )  14073

            JudgeOrgOnlyPowerComRespDto judgeOrgOnlyPowerComRespDto = null;
            JudgeOrgOnlyPowerComReqDto judgeOrgOnlyPowerComReqDto = new JudgeOrgOnlyPowerComReqDto();
            judgeOrgOnlyPowerComReqDto.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:246721_1_14074
            judgeOrgOnlyPowerComReqDto.setPrivacyCode("MGT_ORG_POWER");//CUSTOM_CONVENTION//sourceId:246722_1_14074
            judgeOrgOnlyPowerComReqDto.setBatchMgtOperationType("START_MGT_OBJ");//sourceId:246727_1_14074
            if (reqDto != null) {
                judgeOrgOnlyPowerComReqDto.setOrganizationId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246723_1_14074
            }

            /*D1判断组织架构唯一权限(公共)[3877]   */
            Assert.isNull(judgeOrgOnlyPowerComReqDto.getOrganizationId(), "D1-3判断发起组织批次操作可用(公共)-D1判断组织架构唯一权限(公共)-组织ID不能为空", false);
            Assert.isNull(judgeOrgOnlyPowerComReqDto.getRoleCode(), "D1-3判断发起组织批次操作可用(公共)-D1判断组织架构唯一权限(公共)-角色标识不能为空", false);
            Assert.isNull(judgeOrgOnlyPowerComReqDto.getPrivacyCode(), "D1-3判断发起组织批次操作可用(公共)-D1判断组织架构唯一权限(公共)-权限标识不能为空", false);
            Assert.isNull(judgeOrgOnlyPowerComReqDto.getBatchMgtOperationType(), "D1-3判断发起组织批次操作可用(公共)-D1判断组织架构唯一权限(公共)-批次下管理操作类型不能为空", false);
            judgeOrgOnlyPowerComRespDto = powerService.judgeOrgOnlyPowerCom(judgeOrgOnlyPowerComReqDto);
            Assert.isTrue(judgeOrgOnlyPowerComRespDto == null || judgeOrgOnlyPowerComRespDto.getOutputNum() == null, "返回值不能为空", false);

            judgeOrgOnlyPowerComRespDto_1 = judgeOrgOnlyPowerComRespDto;
//processBranchName:正常结束 ,processBranchId:14075

        } else {
            //else  14076

//异常结束 14077
            throw new BizException("B10000081", "对不起！批次已存在，请直接进入管理~！", false);
        }
        JudgeInitiateOrgBatchUsableComRespDto retData = new JudgeInitiateOrgBatchUsableComRespDto();
        if (judgeOrgOnlyPowerComRespDto_1 != null) {
            retData.setOutputNum(judgeOrgOnlyPowerComRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:246778_1
            retData.setBatchId(judgeOrgOnlyPowerComRespDto_1.getBatchId());//SimpleFieldAssign//sourceId:246779_1
            retData.setBatchCurrentStatus(judgeOrgOnlyPowerComRespDto_1.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:246780_1
        }


        return retData;
    }

    /**
     * D1-1新增组织批次[242]
     * gen by moon at 10/2/2022, 2:47:46 AM
     */
    @Trace(operationName = "D1-1新增组织批次")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddOrgBatchRespDto addOrgBatch(AddOrgBatchReqDto reqDto) {


        String string_1 = null;
        String string_3 = null;
//virtualUsage D1-3判断发起组织批次操作可用(公共)  14079
        JudgeInitiateOrgBatchUsableComRespDto judgeInitiateOrgBatchUsableComRespDto = null;
        JudgeInitiateOrgBatchUsableComReqDto judgeInitiateOrgBatchUsableComReqDto = new JudgeInitiateOrgBatchUsableComReqDto();
        if (reqDto != null) {
            judgeInitiateOrgBatchUsableComReqDto.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246782_1_14079
        }

        /*D1-3判断发起组织批次操作可用(公共)[4150]   */
        Assert.isNull(judgeInitiateOrgBatchUsableComReqDto.getAscriptionObjectId(), "D1-1新增组织批次-D1-3判断发起组织批次操作可用(公共)-归属对象ID不能为空", false);
        judgeInitiateOrgBatchUsableComRespDto = judgeInitiateOrgBatchUsableCom(judgeInitiateOrgBatchUsableComReqDto);
        Assert.isTrue(judgeInitiateOrgBatchUsableComRespDto == null || judgeInitiateOrgBatchUsableComRespDto.getOutputNum() == null, "返回值不能为空", false);


//virtualUsage 1-1-01查询组织架构批次（用于判断是否首次批次）  14080
        Batch batch = null;
        QueryBaseBatchDetailReq queryBaseBatchDetailReq = new QueryBaseBatchDetailReq();
        queryBaseBatchDetailReq.setPurposeTypeCode("ORG");//sourceId:246797_1_14080
        queryBaseBatchDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:285051_1_14080
        if (reqDto != null) {
            queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246798_1_14080
        }

        /*1-1-01查询组织架构批次（用于判断是否首次批次）[44]   */
        Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(), "D1-1新增组织批次-1-1-01查询组织架构批次（用于判断是否首次批次）-归属对象ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(), "D1-1新增组织批次-1-1-01查询组织架构批次（用于判断是否首次批次）-用途类型编码不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getSubjectLifeCycle(), "D1-1新增组织批次-1-1-01查询组织架构批次（用于判断是否首次批次）-主体生命周期不能为空", false);
        batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);


        if ((batch == null)) {
            //if(1-1-01查询组织架构批次（用于判断是否首次批次）.出参 值等于空 )  14081

            String string = null;
            Batch batch_2 = new Batch();
            batch_2.setBatchName(CommonFunctionHelper.getUid());//AUTO_GENERATE//sourceId:323538_1_14082
            batch_2.setPurposeTypeCode("ORG");//sourceId:3459_1_14082
            batch_2.setIsNewbatch("TRUE");//sourceId:246848_1_14082
            batch_2.setIsFirst("TRUE");//sourceId:17396_1_14082
            batch_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23641_1_14082
            batch_2.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23642_1_14082
            if (reqDto != null) {
                batch_2.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:3460_1_14082
            }

            /*1-1-01新增组织架构批次（首次）[41]   */
            Assert.isNull(batch_2.getBatchName(), "D1-1新增组织批次-1-1-01新增组织架构批次（首次）-批次名称不能为空", false);
            Assert.isNull(batch_2.getAscriptionObjectId(), "D1-1新增组织批次-1-1-01新增组织架构批次（首次）-归属对象ID不能为空", false);
            Assert.isNull(batch_2.getPurposeTypeCode(), "D1-1新增组织批次-1-1-01新增组织架构批次（首次）-用途类型编码不能为空", false);
            Assert.isNull(batch_2.getIsNewbatch(), "D1-1新增组织批次-1-1-01新增组织架构批次（首次）-是否最新批次不能为空", false);
            Assert.isNull(batch_2.getIsFirst(), "D1-1新增组织批次-1-1-01新增组织架构批次（首次）-是否首次批次不能为空", false);
            Assert.isNull(batch_2.getSpaceId(), "D1-1新增组织批次-1-1-01新增组织架构批次（首次）-创建于空间ID不能为空", false);
            Assert.isNull(batch_2.getAppId(), "D1-1新增组织批次-1-1-01新增组织架构批次（首次）-创建于联盟应用ID不能为空", false);
            string = mBatchService.addBaseBatch(batch_2);

            string_1 = string;
            boolean bOOLEAN;
            if (string != null) {
                Organization organization = new Organization();
                organization.setCurrentManageObjectType("MEMBER");//sourceId:246717_1_14098
                organization.setManageLockStatus("UNLOCK");//sourceId:246712_1_14098
                organization.setUsingLockStatus("AUTO_LOCK");//sourceId:246715_1_14098
                organization.setReasonOfUsingLock("组织架构正在维护，暂停使用，请耐心等待～");//CUSTOM_CONVENTION//sourceId:246714_1_14098
                organization.setBatchProcessProgress(-1L);//CUSTOM_CONVENTION//sourceId:247259_1_14098
                organization.setDelBatchIsDone("FALSE");//sourceId:247260_1_14098
                if (reqDto != null) {
                    organization.setOrganizationId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246709_1_14098
                }
                if (string != null) {
                    organization.setBatchId(string);//SimpleFieldAssign//sourceId:246716_1_14098
                }

                /*1-3-12修改组织[197]   */
                Assert.isNull(organization.getOrganizationId(), "D1-1新增组织批次-1-3-12修改组织-组织ID不能为空", false);
                Assert.isNull(organization.getCurrentManageObjectType(), "D1-1新增组织批次-1-3-12修改组织-当前管理对象类型不能为空", false);
                Assert.isNull(organization.getManageLockStatus(), "D1-1新增组织批次-1-3-12修改组织-管理锁定状态不能为空", false);
                Assert.isNull(organization.getUsingLockStatus(), "D1-1新增组织批次-1-3-12修改组织-使用锁定状态不能为空", false);
                Assert.isNull(organization.getReasonOfUsingLock(), "D1-1新增组织批次-1-3-12修改组织-使用锁定原因不能为空", false);
                Assert.isNull(organization.getBatchProcessProgress(), "D1-1新增组织批次-1-3-12修改组织-批次处理进度不能为空", false);
                Assert.isNull(organization.getDelBatchIsDone(), "D1-1新增组织批次-1-3-12修改组织-批次处理是否完成不能为空", false);
                Assert.isNull(organization.getBatchId(), "D1-1新增组织批次-1-3-12修改组织-批次ID不能为空", false);
                bOOLEAN = mOrganizationService.updateOrg(organization);


            }
        } else {
            //else  14083

            String string_2 = null;
            Batch batch_3 = new Batch();
            batch_3.setBatchName(CommonFunctionHelper.getUid());//AUTO_GENERATE//sourceId:351236_1_14084
            batch_3.setPurposeTypeCode("ORG");//sourceId:246839_1_14084
            batch_3.setIsFirst("FALSE");//sourceId:246844_1_14084
            batch_3.setIsNewbatch("TRUE");//sourceId:246995_1_14084
            batch_3.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:246996_1_14084
            batch_3.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:246997_1_14084
            if (reqDto != null) {
                batch_3.setAscriptionObjectId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246840_1_14084
            }

            /*1-1-01新增组织架构批次（后续）[41]   */
            Assert.isNull(batch_3.getAscriptionObjectId(), "D1-1新增组织批次-1-1-01新增组织架构批次（后续）-归属对象ID不能为空", false);
            Assert.isNull(batch_3.getBatchName(), "D1-1新增组织批次-1-1-01新增组织架构批次（后续）-批次名称不能为空", false);
            Assert.isNull(batch_3.getPurposeTypeCode(), "D1-1新增组织批次-1-1-01新增组织架构批次（后续）-用途类型编码不能为空", false);
            Assert.isNull(batch_3.getIsFirst(), "D1-1新增组织批次-1-1-01新增组织架构批次（后续）-是否首次批次不能为空", false);
            Assert.isNull(batch_3.getIsNewbatch(), "D1-1新增组织批次-1-1-01新增组织架构批次（后续）-是否最新批次不能为空", false);
            Assert.isNull(batch_3.getSpaceId(), "D1-1新增组织批次-1-1-01新增组织架构批次（后续）-创建于空间ID不能为空", false);
            Assert.isNull(batch_3.getAppId(), "D1-1新增组织批次-1-1-01新增组织架构批次（后续）-创建于联盟应用ID不能为空", false);
            string_2 = mBatchService.addBaseBatch(batch_3);

            string_3 = string_2;
            boolean bOOLEAN_1;
            if (batch != null) {
                Batch batch_4 = new Batch();
                batch_4.setIsNewbatch("FALSE");//sourceId:285073_1_15255
                batch_4.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:285071_1_15255
                batch_4.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:285072_1_15255
                if (batch != null) {
                    batch_4.setBatchId(batch.getBatchId());//SimpleFieldAssign//sourceId:285068_1_15255
                }

                /*1-1-01回改底层框架服务批次（是否最新批次）[42]   */
                Assert.isNull(batch_4.getBatchId(), "D1-1新增组织批次-1-1-01回改底层框架服务批次（是否最新批次）-批次ID不能为空", false);
                Assert.isNull(batch_4.getIsNewbatch(), "D1-1新增组织批次-1-1-01回改底层框架服务批次（是否最新批次）-是否最新批次不能为空", false);
                Assert.isNull(batch_4.getOperationInductionId(), "D1-1新增组织批次-1-1-01回改底层框架服务批次（是否最新批次）-操作人就职记录ID不能为空", false);
                Assert.isNull(batch_4.getOperateTime(), "D1-1新增组织批次-1-1-01回改底层框架服务批次（是否最新批次）-操作时间不能为空", false);
                bOOLEAN_1 = mBatchService.updateBaseBatch(batch_4);


            }
            boolean bOOLEAN_2;
            if (string_2 != null) {
                Organization organization_1 = new Organization();
                organization_1.setCurrentManageObjectType("MEMBER");//sourceId:246717_1_14099
                organization_1.setManageLockStatus("UNLOCK");//sourceId:246712_1_14099
                organization_1.setUsingLockStatus("AUTO_LOCK");//sourceId:246715_1_14099
                organization_1.setReasonOfUsingLock("组织架构正在维护，暂停使用，请耐心等待～");//CUSTOM_CONVENTION//sourceId:246714_1_14099
                organization_1.setBatchProcessProgress(-1L);//CUSTOM_CONVENTION//sourceId:247259_1_14099
                organization_1.setDelBatchIsDone("FALSE");//sourceId:247260_1_14099
                if (reqDto != null) {
                    organization_1.setOrganizationId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246709_1_14099
                }
                if (string_2 != null) {
                    organization_1.setBatchId(string_2);//SimpleFieldAssign//sourceId:246716_1_14099
                }

                /*1-3-12修改组织[197]   */
                Assert.isNull(organization_1.getOrganizationId(), "D1-1新增组织批次-1-3-12修改组织-组织ID不能为空", false);
                Assert.isNull(organization_1.getCurrentManageObjectType(), "D1-1新增组织批次-1-3-12修改组织-当前管理对象类型不能为空", false);
                Assert.isNull(organization_1.getManageLockStatus(), "D1-1新增组织批次-1-3-12修改组织-管理锁定状态不能为空", false);
                Assert.isNull(organization_1.getUsingLockStatus(), "D1-1新增组织批次-1-3-12修改组织-使用锁定状态不能为空", false);
                Assert.isNull(organization_1.getReasonOfUsingLock(), "D1-1新增组织批次-1-3-12修改组织-使用锁定原因不能为空", false);
                Assert.isNull(organization_1.getBatchProcessProgress(), "D1-1新增组织批次-1-3-12修改组织-批次处理进度不能为空", false);
                Assert.isNull(organization_1.getDelBatchIsDone(), "D1-1新增组织批次-1-3-12修改组织-批次处理是否完成不能为空", false);
                Assert.isNull(organization_1.getBatchId(), "D1-1新增组织批次-1-3-12修改组织-批次ID不能为空", false);
                bOOLEAN_2 = mOrganizationService.updateOrg(organization_1);


            }
        }
//virtualUsage D1-1修改检查项状态(组织成员管理检查项)  14094
        UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
        UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto = new UpdateCheckItemStatComReqDto();
        updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:144788_1_14094
        updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:144789_1_14094
        updateCheckItemStatComReqDto.setIsComplete("FALSE");//sourceId:144787_1_14094
        if (reqDto != null) {
            updateCheckItemStatComReqDto.setEntityId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:144790_1_14094
        }

        /*D1-1修改检查项状态(组织成员管理检查项)[947]   */
        Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(), "D1-1新增组织批次-D1-1修改检查项状态(组织成员管理检查项)-检查项标识不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(), "D1-1新增组织批次-D1-1修改检查项状态(组织成员管理检查项)-内容对象类型编码不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto.getEntityId(), "D1-1新增组织批次-D1-1修改检查项状态(组织成员管理检查项)-内容对象实例ID不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(), "D1-1新增组织批次-D1-1修改检查项状态(组织成员管理检查项)-是否已完成不能为空", false);
        updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);


//virtualUsage D1-1修改检查项状态(公共)(组织管理检查项)  14095
        UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto_1 = null;
        UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto_1 = new UpdateCheckItemStatComReqDto();
        updateCheckItemStatComReqDto_1.setCheckItemCode("ORG_MGT_CHECK");//CUSTOM_CONVENTION//sourceId:246788_1_14095
        updateCheckItemStatComReqDto_1.setObjectTypeCode("ORG_CHECK");//sourceId:246789_1_14095
        updateCheckItemStatComReqDto_1.setIsComplete("FALSE");//sourceId:246787_1_14095
        if (reqDto != null) {
            updateCheckItemStatComReqDto_1.setEntityId(reqDto.getAscriptionObjectId());//SimpleFieldAssign//sourceId:246790_1_14095
        }

        /*D1-1修改检查项状态(公共)(组织管理检查项)[947]   */
        Assert.isNull(updateCheckItemStatComReqDto_1.getCheckItemCode(), "D1-1新增组织批次-D1-1修改检查项状态(公共)(组织管理检查项)-检查项标识不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto_1.getObjectTypeCode(), "D1-1新增组织批次-D1-1修改检查项状态(公共)(组织管理检查项)-内容对象类型编码不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto_1.getEntityId(), "D1-1新增组织批次-D1-1修改检查项状态(公共)(组织管理检查项)-内容对象实例ID不能为空", false);
        Assert.isNull(updateCheckItemStatComReqDto_1.getIsComplete(), "D1-1新增组织批次-D1-1修改检查项状态(公共)(组织管理检查项)-是否已完成不能为空", false);
        updateCheckItemStatComRespDto_1 = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto_1);


//processBranchName:正常结束 ,processBranchId:14097

        AddOrgBatchRespDto retData = new AddOrgBatchRespDto();
        if (string_1 != null) {
            retData.setBatchId(string_1);//SimpleFieldAssign//sourceId:246793_1
        }
        if (string_3 != null) {
            retData.setBatchId(string_3);//SimpleFieldAssign//sourceId:246793_1
        }


        return retData;
    }

    /**
     * D1判断组织架构进入管理可用(公共)[3813]
     * gen by moon at 8/24/2023, 1:19:04 PM
     */
    @Trace(operationName = "D1判断组织架构进入管理可用(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeOrgStructureMgtUsableComRespDto judgeOrgStructureMgtUsableCom(JudgeOrgStructureMgtUsableComReqDto reqDto) {


        Batch batch_1 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_7 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_9 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_11 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_13 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_15 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_17 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_19 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_21 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_23 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_25 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_27 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_29 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_31 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_33 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_35 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_37 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_39 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_59 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_61 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_63 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_65 = null;
//virtualUsage M1-传输0  14039
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
        receptionServiceReq.setOutputNum(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:245169_1_14039

        /*M1-传输0[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getOutputNum(), "D1判断组织架构进入管理可用(公共)-M1-传输0-传输数值（整数型）不能为空", false);
        receptionServiceRes = nbBatch.queryReceiveFieldDetail(receptionServiceReq);


//virtualUsage M1-传输1  14042
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_1 = new QueryReceiveFieldDetailReqDto();
        receptionServiceReq_1.setOutputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:245170_1_14042

        /*M1-传输1[3715]  用于特殊方法接收上游入参。 */

        receptionServiceRes_2 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_1);


//virtualUsage M-传输2  14041
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_4 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_2 = new QueryReceiveFieldDetailReqDto();
        receptionServiceReq_2.setOutputNum(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:245229_1_14041

        /*M-传输2[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_2.getOutputNum(), "D1判断组织架构进入管理可用(公共)-M-传输2-传输数值（整数型）不能为空", false);
        receptionServiceRes_4 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_2);


//virtualUsage 1-1-01查询当前最新批次信息  11910
        Batch batch = null;
        QueryBaseBatchDetailReq queryBaseBatchDetailReq = new QueryBaseBatchDetailReq();
        queryBaseBatchDetailReq.setPurposeTypeCode("ORG");//sourceId:183442_1_11910
        queryBaseBatchDetailReq.setIsNewbatch("TRUE");//sourceId:183547_1_11910
        if (reqDto != null) {
            queryBaseBatchDetailReq.setAscriptionObjectId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:183443_1_11910
        }

        /*1-1-01查询当前最新批次信息[44]   */
        Assert.isNull(queryBaseBatchDetailReq.getAscriptionObjectId(), "D1判断组织架构进入管理可用(公共)-1-1-01查询当前最新批次信息-归属对象ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getPurposeTypeCode(), "D1判断组织架构进入管理可用(公共)-1-1-01查询当前最新批次信息-用途类型编码不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getIsNewbatch(), "D1判断组织架构进入管理可用(公共)-1-1-01查询当前最新批次信息-是否最新批次不能为空", false);
        batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        batch_1 = batch;
//virtualUsage 1-3-12查询组织管理状态等信息  11911
        Organization organization = null;
        QueryOrgDetailReq queryOrgDetailReq = new QueryOrgDetailReq();
        queryOrgDetailReq.setIsArchive("FALSE");//sourceId:183463_1_11911
        if (reqDto != null) {
            queryOrgDetailReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:183446_1_11911
        }

        /*1-3-12查询组织管理状态等信息[201]   */
        Assert.isNull(queryOrgDetailReq.getOrganizationId(), "D1判断组织架构进入管理可用(公共)-1-3-12查询组织管理状态等信息-组织ID不能为空", false);
        Assert.isNull(queryOrgDetailReq.getIsArchive(), "D1判断组织架构进入管理可用(公共)-1-3-12查询组织管理状态等信息-是否存档不能为空", false);
        organization = mOrganizationService.queryOrgDetail(queryOrgDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 1-1-22查询组织架构管理检查项状态  11935
        StatusCheckItem statusCheckItem = null;
        QueryCheckItemStatDetailReq queryCheckItemStatDetailReq = new QueryCheckItemStatDetailReq();
        queryCheckItemStatDetailReq.setCheckItemCode("ORG_MGT_CHECK");//CUSTOM_CONVENTION//sourceId:184139_1_11935
        queryCheckItemStatDetailReq.setObjectTypeCode("ORG_CHECK");//sourceId:184140_1_11935
        if (reqDto != null) {
            queryCheckItemStatDetailReq.setEntityId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:184141_1_11935
        }

        /*1-1-22查询组织架构管理检查项状态[327]   */
        Assert.isNull(queryCheckItemStatDetailReq.getCheckItemCode(), "D1判断组织架构进入管理可用(公共)-1-1-22查询组织架构管理检查项状态-检查项标识不能为空", false);
        Assert.isNull(queryCheckItemStatDetailReq.getObjectTypeCode(), "D1判断组织架构进入管理可用(公共)-1-1-22查询组织架构管理检查项状态-内容对象类型编码不能为空", false);
        Assert.isNull(queryCheckItemStatDetailReq.getEntityId(), "D1判断组织架构进入管理可用(公共)-1-1-22查询组织架构管理检查项状态-内容对象实例ID不能为空", false);
        statusCheckItem = mStatusCheckItemService.queryCheckItemStatDetail(queryCheckItemStatDetailReq)/*vcase invoke 本地 method 方法调用;*/;
        Assert.isTrue(statusCheckItem == null || statusCheckItem.getStatusCheckItemId() == null, "找不到数据，系统异常", false);


//virtualUsage 1-3-16查询部门类型字典列表  14060
        List<TypeDictionary> listTypeDictionary = new ArrayList<>();
        QueryOrgClassListReq queryOrgClassListReq = new QueryOrgClassListReq();
        queryOrgClassListReq.setPurposeCode("DEPT_TYPE");//sourceId:245600_1_14060
        queryOrgClassListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:245604_1_14060
        queryOrgClassListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:245607_1_14060
        if (reqDto != null) {
            queryOrgClassListReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:245601_1_14060
        }

        /*1-3-16查询部门类型字典列表[295]   */
        Assert.isNull(queryOrgClassListReq.getOrganizationId(), "D1判断组织架构进入管理可用(公共)-1-3-16查询部门类型字典列表-组织ID不能为空", false);
        Assert.isNull(queryOrgClassListReq.getPurposeCode(), "D1判断组织架构进入管理可用(公共)-1-3-16查询部门类型字典列表-类型用途编码不能为空", false);
        Assert.isNull(queryOrgClassListReq.getSubjectLifeCycle(), "D1判断组织架构进入管理可用(公共)-1-3-16查询部门类型字典列表-主体生命周期不能为空", false);
        Assert.isNull(queryOrgClassListReq.getSpaceId(), "D1判断组织架构进入管理可用(公共)-1-3-16查询部门类型字典列表-创建于空间ID不能为空", false);
        listTypeDictionary = mTypeDictionaryService.queryOrgClassList(queryOrgClassListReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 1-3-09查询部门列表（用于判断成员开始管理是否可用）  14085
        List<Dept> listDept = new ArrayList<>();
        QueryDeptListReq queryDeptListReq = new QueryDeptListReq();
        queryDeptListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:246862_1_14085
        if (reqDto != null) {
            queryDeptListReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:246860_1_14085
        }

        /*1-3-09查询部门列表（用于判断成员开始管理是否可用）[217]   */
        Assert.isNull(queryDeptListReq.getOrganizationId(), "D1判断组织架构进入管理可用(公共)-1-3-09查询部门列表（用于判断成员开始管理是否可用）-组织ID不能为空", false);
        Assert.isNull(queryDeptListReq.getSubjectLifeCycle(), "D1判断组织架构进入管理可用(公共)-1-3-09查询部门列表（用于判断成员开始管理是否可用）-主体生命周期不能为空", false);
        listDept = mDeptService.queryDeptList(queryDeptListReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 1-3-09查询部门列表（用于判断部门维护完成是否可用）  15280
        List<Dept> listDept_2 = new ArrayList<>();
        QueryDeptListReq queryDeptListReq_1 = new QueryDeptListReq();
        queryDeptListReq_1.setSubjectLifeCycle("EDITING");//sourceId:286091_1_15280
        if (reqDto != null) {
            queryDeptListReq_1.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:286089_1_15280
        }

        /*1-3-09查询部门列表（用于判断部门维护完成是否可用）[217]   */
        Assert.isNull(queryDeptListReq_1.getOrganizationId(), "D1判断组织架构进入管理可用(公共)-1-3-09查询部门列表（用于判断部门维护完成是否可用）-组织ID不能为空", false);
        Assert.isNull(queryDeptListReq_1.getSubjectLifeCycle(), "D1判断组织架构进入管理可用(公共)-1-3-09查询部门列表（用于判断部门维护完成是否可用）-主体生命周期不能为空", false);
        listDept_2 = mDeptService.queryDeptList(queryDeptListReq_1)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage M1-成员开始管理  14043
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_6 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_3 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_3.setStartMgtObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:184161_1_14043
        }

        /*M1-成员开始管理[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_3.getStartMgtObj(), "D1判断组织架构进入管理可用(公共)-M1-成员开始管理-开始管理不能为空", false);
        receptionServiceRes_6 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_3);


        receptionServiceRes_7 = receptionServiceRes_6;
//virtualUsage M1-成员暂停对外使用  14044
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_8 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_4 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_4.setSuspendedObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183849_1_14044
        }

        /*M1-成员暂停对外使用[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_4.getSuspendedObj(), "D1判断组织架构进入管理可用(公共)-M1-成员暂停对外使用-暂停对外使用不能为空", false);
        receptionServiceRes_8 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_4);


        receptionServiceRes_9 = receptionServiceRes_8;
//virtualUsage M1-成员恢复对外使用  14056
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_10 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_5 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_5.setRestoreObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183851_1_14056
        }

        /*M1-成员恢复对外使用[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_5.getRestoreObj(), "D1判断组织架构进入管理可用(公共)-M1-成员恢复对外使用-恢复对外使用不能为空", false);
        receptionServiceRes_10 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_5);


        receptionServiceRes_11 = receptionServiceRes_10;
//virtualUsage M1-成员发布生效  14045
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_12 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_6 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_6.setReleaseEffectObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183741_1_14045
        }

        /*M1-成员发布生效[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_6.getReleaseEffectObj(), "D1判断组织架构进入管理可用(公共)-M1-成员发布生效-发布生效不能为空", false);
        receptionServiceRes_12 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_6);


        receptionServiceRes_13 = receptionServiceRes_12;
//virtualUsage M1-成员取消设置完成  14046
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_14 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_7 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_7.setCancelSetCompleteObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183747_1_14046
        }

        /*M1-成员取消设置完成[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_7.getCancelSetCompleteObj(), "D1判断组织架构进入管理可用(公共)-M1-成员取消设置完成-取消设置完成不能为空", false);
        receptionServiceRes_14 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_7);


        receptionServiceRes_15 = receptionServiceRes_14;
//virtualUsage M1-成员确认设置完成  14047
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_16 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_8 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_8.setSetCompleteObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183745_1_14047
        }

        /*M1-成员确认设置完成[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_8.getSetCompleteObj(), "D1判断组织架构进入管理可用(公共)-M1-成员确认设置完成-确认设置完成不能为空", false);
        receptionServiceRes_16 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_8);


        receptionServiceRes_17 = receptionServiceRes_16;
//virtualUsage M1-成员撤销修订  14048
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_18 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_9 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_9.setCancelRevisionObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183744_1_14048
        }

        /*M1-成员撤销修订[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_9.getCancelRevisionObj(), "D1判断组织架构进入管理可用(公共)-M1-成员撤销修订-撤销修订不能为空", false);
        receptionServiceRes_18 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_9);


        receptionServiceRes_19 = receptionServiceRes_18;
//virtualUsage M1-成员变更记录  14049
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_20 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_10 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_10.setChangeRecordObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183853_1_14049
        }

        /*M1-成员变更记录[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_10.getChangeRecordObj(), "D1判断组织架构进入管理可用(公共)-M1-成员变更记录-变更记录不能为空", false);
        receptionServiceRes_20 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_10);


        receptionServiceRes_21 = receptionServiceRes_20;
//virtualUsage M1-成员锁定原因  14050
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_22 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_11 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_11.setLockReasonObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183954_1_14050
        }

        /*M1-成员锁定原因[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_11.getLockReasonObj(), "D1判断组织架构进入管理可用(公共)-M1-成员锁定原因-锁定原因不能为空", false);
        receptionServiceRes_22 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_11);


        receptionServiceRes_23 = receptionServiceRes_22;
//virtualUsage M1-成员批次现状  14051
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_24 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_12 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_12.setBatchCurrentStatus(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:198886_1_14051
        }

        /*M1-成员批次现状[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_12.getBatchCurrentStatus(), "D1判断组织架构进入管理可用(公共)-M1-成员批次现状-批次现状不能为空", false);
        receptionServiceRes_24 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_12);


        receptionServiceRes_25 = receptionServiceRes_24;
//virtualUsage M1-成员首次管理操作  14053
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_26 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_13 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_13.setFirstOperation(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:199150_1_14053
        }

        /*M1-成员首次管理操作[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_13.getFirstOperation(), "D1判断组织架构进入管理可用(公共)-M1-成员首次管理操作-首次操作不能为空", false);
        receptionServiceRes_26 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_13);


        receptionServiceRes_27 = receptionServiceRes_26;
//virtualUsage M1-成员后续管理操作  14054
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_28 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_14 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_14.setTrailingOperation(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:199155_1_14054
        }

        /*M1-成员后续管理操作[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_14.getTrailingOperation(), "D1判断组织架构进入管理可用(公共)-M1-成员后续管理操作-后续操作不能为空", false);
        receptionServiceRes_28 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_14);


        receptionServiceRes_29 = receptionServiceRes_28;
//virtualUsage M1-成员混合管理操作  14055
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_30 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_15 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_15.setMixtureOperation(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:198885_1_14055
        }

        /*M1-成员混合管理操作[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_15.getMixtureOperation(), "D1判断组织架构进入管理可用(公共)-M1-成员混合管理操作-全批次操作不能为空", false);
        receptionServiceRes_30 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_15);


        receptionServiceRes_31 = receptionServiceRes_30;
//virtualUsage M1-部门开始管理  14061
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_32 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_16 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_16.setDeptStartMgt(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:245616_1_14061
        }

        /*M1-部门开始管理[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_16.getDeptStartMgt(), "D1判断组织架构进入管理可用(公共)-M1-部门开始管理-部门开始管理不能为空", false);
        receptionServiceRes_32 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_16);


        receptionServiceRes_33 = receptionServiceRes_32;
//virtualUsage M1-部门管理操作  14406
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_34 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_17 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_17.setDeptOperation(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:254943_1_14406
        }

        /*M1-部门管理操作[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_17.getDeptOperation(), "D1判断组织架构进入管理可用(公共)-M1-部门管理操作-部门管理操作不能为空", false);
        receptionServiceRes_34 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_17);


        receptionServiceRes_35 = receptionServiceRes_34;
//virtualUsage M1-部门维护完成  14062
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_36 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_18 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_18.setDeptPreserveAchieve(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:245614_1_14062
        }

        /*M1-部门维护完成[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_18.getDeptPreserveAchieve(), "D1判断组织架构进入管理可用(公共)-M1-部门维护完成-部门维护完成不能为空", false);
        receptionServiceRes_36 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_18);


        receptionServiceRes_37 = receptionServiceRes_36;
//virtualUsage M1-部门变更记录  14847
        //ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_38 = null;
        QueryReceiveFieldDetailReqDto receptionServiceReq_19 = new QueryReceiveFieldDetailReqDto();
        if (receptionServiceRes != null) {
            receptionServiceReq_19.setDeptChangeRecordObj(receptionServiceRes.getOutputNum() != null ? String.valueOf(receptionServiceRes.getOutputNum()) : "");//SimpleFieldAssign//sourceId:261687_1_14847
        }

        /*M1-部门变更记录[3715]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_19.getDeptChangeRecordObj(), "D1判断组织架构进入管理可用(公共)-M1-部门变更记录-部门变更记录不能为空", false);
        receptionServiceRes_38 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_19);


        receptionServiceRes_39 = receptionServiceRes_38;
        if ((organization != null && organization.getCurrentManageObjectType() != null && !(organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER")) && organization != null && organization.getManageLockStatus() != null && !(organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK")))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 值不等于空  and 1-3-12查询组织管理状态等信息.当前管理对象类型 不等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 值不等于空  and 1-3-12查询组织管理状态等信息.管理锁定状态 不等于 未锁定))  11912

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_40 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_20 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_20.setStartMgtObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:184161_1_11934
            }

            /*M1-成员开始管理[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_20.getStartMgtObj(), "D1判断组织架构进入管理可用(公共)-M1-成员开始管理-开始管理不能为空", false);
            receptionServiceRes_40 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_20);


            receptionServiceRes_7 = receptionServiceRes_40;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("UNMANNED_MGT") && organization != null && organization.getUsingLockStatus() != null && organization.getUsingLockStatus().equals("UNLOCK")) && (organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("COMMON_LOCK") || organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("AUTO_LOCK"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 无人管理 and 1-3-12查询组织管理状态等信息.使用锁定状态 等于 未锁定) and (1-3-12查询组织管理状态等信息.管理锁定状态 等于 普通锁定 or 1-3-12查询组织管理状态等信息.管理锁定状态 等于 自动锁定))  11973

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_41 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_21 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_21.setSuspendedObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183849_1_11975
            }

            /*M1-成员暂停对外使用[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_21.getSuspendedObj(), "D1判断组织架构进入管理可用(公共)-M1-成员暂停对外使用-暂停对外使用不能为空", false);
            receptionServiceRes_41 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_21);


            receptionServiceRes_9 = receptionServiceRes_41;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("UNMANNED_MGT")) && (organization != null && organization.getUsingLockStatus() != null && organization.getUsingLockStatus().equals("COMMON_LOCK") || organization != null && organization.getUsingLockStatus() != null && organization.getUsingLockStatus().equals("AUTO_LOCK")) && (organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("COMMON_LOCK") || organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("AUTO_LOCK"))) {
            //if(1-3-12查询组织管理状态等信息.当前管理对象类型 等于 无人管理 and (1-3-12查询组织管理状态等信息.使用锁定状态 等于 普通锁定 or 1-3-12查询组织管理状态等信息.使用锁定状态 等于 自动锁定) and (1-3-12查询组织管理状态等信息.管理锁定状态 等于 普通锁定 or 1-3-12查询组织管理状态等信息.管理锁定状态 等于 自动锁定))  11972

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_42 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_22 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_22.setRestoreObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183851_1_11976
            }

            /*M1-成员恢复对外使用[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_22.getRestoreObj(), "D1判断组织架构进入管理可用(公共)-M1-成员恢复对外使用-恢复对外使用不能为空", false);
            receptionServiceRes_42 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_22);


            receptionServiceRes_11 = receptionServiceRes_42;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK") && statusCheckItem != null && statusCheckItem.getIsComplete() != null && statusCheckItem.getIsComplete().equals("TRUE") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 是 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11971

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_43 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_23 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_23.setReleaseEffectObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183741_1_11979
            }

            /*M1-成员发布生效[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_23.getReleaseEffectObj(), "D1判断组织架构进入管理可用(公共)-M1-成员发布生效-发布生效不能为空", false);
            receptionServiceRes_43 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_23);


            receptionServiceRes_13 = receptionServiceRes_43;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK") && statusCheckItem != null && statusCheckItem.getIsComplete() != null && statusCheckItem.getIsComplete().equals("TRUE") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 是 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11970

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_44 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_24 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_24.setCancelSetCompleteObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183747_1_11982
            }

            /*M1-成员取消设置完成[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_24.getCancelSetCompleteObj(), "D1判断组织架构进入管理可用(公共)-M1-成员取消设置完成-取消设置完成不能为空", false);
            receptionServiceRes_44 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_24);


            receptionServiceRes_15 = receptionServiceRes_44;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK") && statusCheckItem != null && statusCheckItem.getIsComplete() != null && statusCheckItem.getIsComplete().equals("FALSE") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11968

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_45 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_25 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_25.setSetCompleteObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183745_1_11983
            }

            /*M1-成员确认设置完成[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_25.getSetCompleteObj(), "D1判断组织架构进入管理可用(公共)-M1-成员确认设置完成-确认设置完成不能为空", false);
            receptionServiceRes_45 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_25);


            receptionServiceRes_17 = receptionServiceRes_45;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK") && statusCheckItem != null && statusCheckItem.getIsComplete() != null && statusCheckItem.getIsComplete().equals("FALSE") && batch != null && batch.getIsFirst() != null && batch.getIsFirst().equals("FALSE") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-1-01查询当前最新批次信息.是否首次批次 等于 否 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11967

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_46 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_26 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_26.setCancelRevisionObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183744_1_11989
            }

            /*M1-成员撤销修订[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_26.getCancelRevisionObj(), "D1判断组织架构进入管理可用(公共)-M1-成员撤销修订-撤销修订不能为空", false);
            receptionServiceRes_46 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_26);


            receptionServiceRes_19 = receptionServiceRes_46;
        }
        if ((batch != null && batch != null && batch.getIsFirst() != null && batch.getIsFirst().equals("FALSE"))) {
            //if((1-1-01查询当前最新批次信息.出参 值不等于空  and 1-1-01查询当前最新批次信息.是否首次批次 等于 否))  11988

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_47 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_27 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_27.setChangeRecordObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183853_1_11990
            }

            /*M1-成员变更记录[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_27.getChangeRecordObj(), "D1判断组织架构进入管理可用(公共)-M1-成员变更记录-变更记录不能为空", false);
            receptionServiceRes_47 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_27);


            receptionServiceRes_21 = receptionServiceRes_47;
        }
        if ((!(organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER")) && !(organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK")) && !(organization != null && organization.getUsingLockStatus() != null && organization.getUsingLockStatus().equals("UNLOCK")))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 不等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 不等于 未锁定 and 1-3-12查询组织管理状态等信息.使用锁定状态 不等于 未锁定))  11987

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_48 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_28 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_28.setLockReasonObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:183954_1_11991
            }

            /*M1-成员锁定原因[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_28.getLockReasonObj(), "D1判断组织架构进入管理可用(公共)-M1-成员锁定原因-锁定原因不能为空", false);
            receptionServiceRes_48 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_28);


            receptionServiceRes_23 = receptionServiceRes_48;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK") && batch != null && batch.getIsFirst() != null && batch.getIsFirst().equals("TRUE") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-01查询当前最新批次信息.是否首次批次 等于 是 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11986

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_49 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_29 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_29.setBatchCurrentStatus(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:198886_1_11993
            }

            /*M1-成员批次现状[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_29.getBatchCurrentStatus(), "D1判断组织架构进入管理可用(公共)-M1-成员批次现状-批次现状不能为空", false);
            receptionServiceRes_49 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_29);


            receptionServiceRes_25 = receptionServiceRes_49;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK") && batch != null && batch.getIsFirst() != null && batch.getIsFirst().equals("FALSE") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-1-01查询当前最新批次信息.是否首次批次 等于 否 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑))  11985

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_50 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_30 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_4 != null) {
                receptionServiceReq_30.setBatchCurrentStatus(receptionServiceRes_4.getOutputNum() != null ? String.valueOf(receptionServiceRes_4.getOutputNum()) : "");//SimpleFieldAssign//sourceId:198886_1_14619
            }

            /*M1-成员批次现状[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_30.getBatchCurrentStatus(), "D1判断组织架构进入管理可用(公共)-M1-成员批次现状-批次现状不能为空", false);
            receptionServiceRes_50 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_30);


            receptionServiceRes_25 = receptionServiceRes_50;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && statusCheckItem != null && statusCheckItem.getIsComplete() != null && statusCheckItem.getIsComplete().equals("FALSE") && batch != null && batch.getIsFirst() != null && batch.getIsFirst().equals("TRUE") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-1-01查询当前最新批次信息.是否首次批次 等于 是 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定))  12681

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_51 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_31 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_31.setFirstOperation(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:199150_1_12691
            }

            /*M1-成员首次管理操作[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_31.getFirstOperation(), "D1判断组织架构进入管理可用(公共)-M1-成员首次管理操作-首次操作不能为空", false);
            receptionServiceRes_51 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_31);


            receptionServiceRes_27 = receptionServiceRes_51;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && statusCheckItem != null && statusCheckItem.getIsComplete() != null && statusCheckItem.getIsComplete().equals("FALSE") && batch != null && batch.getIsFirst() != null && batch.getIsFirst().equals("FALSE") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-1-01查询当前最新批次信息.是否首次批次 等于 否 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定))  12679

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_52 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_32 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_32.setTrailingOperation(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:199155_1_12692
            }

            /*M1-成员后续管理操作[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_32.getTrailingOperation(), "D1判断组织架构进入管理可用(公共)-M1-成员后续管理操作-后续操作不能为空", false);
            receptionServiceRes_52 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_32);


            receptionServiceRes_29 = receptionServiceRes_52;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && statusCheckItem != null && statusCheckItem.getIsComplete() != null && statusCheckItem.getIsComplete().equals("FALSE") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK")) && (batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-22查询组织架构管理检查项状态.是否已完成 等于 否 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定) and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑)  12694

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_53 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_33 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_33.setMixtureOperation(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:198885_1_12695
            }

            /*M1-成员混合管理操作[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_33.getMixtureOperation(), "D1判断组织架构进入管理可用(公共)-M1-成员混合管理操作-全批次操作不能为空", false);
            receptionServiceRes_53 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_33);


            receptionServiceRes_31 = receptionServiceRes_53;
        }
        if ((organization != null && organization.getManageLockStatus() != null && organization != null && organization.getCurrentManageObjectType() != null && !(organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("DEPTMENT")))) {
            //if((1-3-12查询组织管理状态等信息.管理锁定状态 值不等于空  and 1-3-12查询组织管理状态等信息.当前管理对象类型 值不等于空  and 1-3-12查询组织管理状态等信息.当前管理对象类型 不等于 部门))  14059

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_54 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_34 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_34.setDeptStartMgt(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:245616_1_14063
            }

            /*M1-部门开始管理[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_34.getDeptStartMgt(), "D1判断组织架构进入管理可用(公共)-M1-部门开始管理-部门开始管理不能为空", false);
            receptionServiceRes_54 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_34);


            receptionServiceRes_33 = receptionServiceRes_54;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("DEPTMENT") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK"))) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 部门 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定))  14398

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_55 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_35 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_35.setDeptOperation(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:254943_1_14400
            }

            /*M1-部门管理操作[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_35.getDeptOperation(), "D1判断组织架构进入管理可用(公共)-M1-部门管理操作-部门管理操作不能为空", false);
            receptionServiceRes_55 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_35);


            receptionServiceRes_35 = receptionServiceRes_55;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("DEPTMENT") && organization != null && organization.getManageLockStatus() != null && organization.getManageLockStatus().equals("UNLOCK") && listDept_2 != null && listDept_2 != null && listDept_2.size() == 0)) {
            //if((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 部门 and 1-3-12查询组织管理状态等信息.管理锁定状态 等于 未锁定 and 1-3-09查询部门列表（用于判断部门维护完成是否可用）.部门列表数据集条数 等于 0))  14058

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_56 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_36 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_36.setDeptPreserveAchieve(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:245614_1_14064
            }

            /*M1-部门维护完成[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_36.getDeptPreserveAchieve(), "D1判断组织架构进入管理可用(公共)-M1-部门维护完成-部门维护完成不能为空", false);
            receptionServiceRes_56 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_36);


            receptionServiceRes_37 = receptionServiceRes_56;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null)) {
            //if(1-3-12查询组织管理状态等信息.当前管理对象类型 值不等于空 )  14849

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_57 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_37 = new QueryReceiveFieldDetailReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_37.setDeptChangeRecordObj(receptionServiceRes_2.getOutputNum() != null ? String.valueOf(receptionServiceRes_2.getOutputNum()) : "");//SimpleFieldAssign//sourceId:261687_1_14850
            }

            /*M1-部门变更记录[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_37.getDeptChangeRecordObj(), "D1判断组织架构进入管理可用(公共)-M1-部门变更记录-部门变更记录不能为空", false);
            receptionServiceRes_57 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_37);


            receptionServiceRes_39 = receptionServiceRes_57;
        }
        if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("UNMANNED_MGT"))) {
            //if(1-3-12查询组织管理状态等信息.当前管理对象类型 等于 无人管理)  14859

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_58 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_38 = new QueryReceiveFieldDetailReqDto();
            receptionServiceReq_38.setMemtMgtSence("ORG_CAN_MGT_SEN");//sourceId:262133_1_14868

            /*M1-组织架构可以开始管理场景[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_38.getMemtMgtSence(), "D1判断组织架构进入管理可用(公共)-M1-组织架构可以开始管理场景-组织架构管理场景不能为空", false);
            receptionServiceRes_58 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_38);


            receptionServiceRes_59 = receptionServiceRes_58;
        } else if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING") && batch != null && batch.getIsFirst() != null && batch.getIsFirst().equals("TRUE"))) {
            //elseif((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑 and 1-1-01查询当前最新批次信息.是否首次批次 等于 是))  14861

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_60 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_39 = new QueryReceiveFieldDetailReqDto();
            receptionServiceReq_39.setMemtMgtSence("MEM_FIR_BATCH_MGT_SEN");//sourceId:262401_1_14869

            /*M1-成员首次管理场景[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_39.getMemtMgtSence(), "D1判断组织架构进入管理可用(公共)-M1-成员首次管理场景-组织架构管理场景不能为空", false);
            receptionServiceRes_60 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_39);


            receptionServiceRes_61 = receptionServiceRes_60;
        } else if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("MEMBER") && batch != null && batch.getSubjectLifeCycle() != null && batch.getSubjectLifeCycle().equals("EDITING") && batch != null && batch.getIsFirst() != null && batch.getIsFirst().equals("FALSE"))) {
            //elseif((1-3-12查询组织管理状态等信息.当前管理对象类型 等于 成员 and 1-1-01查询当前最新批次信息.主体生命周期 等于 正在编辑 and 1-1-01查询当前最新批次信息.是否首次批次 等于 否))  14862

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_62 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_40 = new QueryReceiveFieldDetailReqDto();
            receptionServiceReq_40.setMemtMgtSence("MEM_SUB_BATCH_MGT_SEN");//sourceId:262426_1_14870

            /*M1-成员后续管理场景[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_40.getMemtMgtSence(), "D1判断组织架构进入管理可用(公共)-M1-成员后续管理场景-组织架构管理场景不能为空", false);
            receptionServiceRes_62 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_40);


            receptionServiceRes_63 = receptionServiceRes_62;
        } else if ((organization != null && organization.getCurrentManageObjectType() != null && organization.getCurrentManageObjectType().equals("DEPTMENT"))) {
            //elseif(1-3-12查询组织管理状态等信息.当前管理对象类型 等于 部门)  14863

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_64 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_41 = new QueryReceiveFieldDetailReqDto();
            receptionServiceReq_41.setMemtMgtSence("DEPT_MGT_SEN");//sourceId:262427_1_14871

            /*M1-部门管理场景[3715]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_41.getMemtMgtSence(), "D1判断组织架构进入管理可用(公共)-M1-部门管理场景-组织架构管理场景不能为空", false);
            receptionServiceRes_64 = nbBatch.queryReceiveFieldDetail(receptionServiceReq_41);


            receptionServiceRes_65 = receptionServiceRes_64;
        } else if ((organization != null && organization.getCurrentManageObjectType() == null)) {
            //elseif(1-3-12查询组织管理状态等信息.当前管理对象类型 值等于空 )  14864

//异常结束 14873
            throw new BizException("10300093", "对不起，当前谁在管理出现未知异常，请联系管理员。~", false);
        } else if ((organization != null && organization.getManageLockStatus() == null)) {
            //elseif(1-3-12查询组织管理状态等信息.管理锁定状态 值等于空 )  14865

//异常结束 14874
            throw new BizException("10300095", "对不起！管理状态未知异常，请联系管理员~", false);
        } else if ((organization != null && organization.getUsingLockStatus() == null)) {
            //elseif(1-3-12查询组织管理状态等信息.使用锁定状态 值等于空 )  14866

//异常结束 14875
            throw new BizException("10300095", "对不起！管理状态未知异常，请联系管理员~", false);
        } else if ((statusCheckItem == null || statusCheckItem != null && statusCheckItem.getIsComplete() == null)) {
            //elseif((1-1-22查询组织架构管理检查项状态.出参 值等于空  or 1-1-22查询组织架构管理检查项状态.是否已完成 值等于空 ))  14872

//异常结束 14876
            throw new BizException("10300107", "对不起，管理完成状态出现未知异常，请联系管理员~。", false);
        }
//processBranchName:正常结束 ,processBranchId:11996

        JudgeOrgStructureMgtUsableComRespDto retData = new JudgeOrgStructureMgtUsableComRespDto();
        if (batch_1 != null) {
            retData.setBatchId(batch_1.getBatchId());//SimpleFieldAssign//sourceId:184256_1
        }
        if (receptionServiceRes_25 != null) {
            retData.setBatchCurrentStatus(receptionServiceRes_25.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:184218_1
            retData.setBatchCurrentStatus(receptionServiceRes_25.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:184218_1
        }
        if (receptionServiceRes_7 != null) {
            retData.setStartMgtObj(receptionServiceRes_7.getStartMgtObj());//SimpleFieldAssign//sourceId:184221_1
        }
        if (receptionServiceRes_9 != null) {
            retData.setSuspendedObj(receptionServiceRes_9.getSuspendedObj());//SimpleFieldAssign//sourceId:184212_1
        }
        if (receptionServiceRes_11 != null) {
            retData.setRestoreObj(receptionServiceRes_11.getRestoreObj());//SimpleFieldAssign//sourceId:184213_1
        }
        if (receptionServiceRes_23 != null) {
            retData.setLockReasonObj(receptionServiceRes_23.getLockReasonObj());//SimpleFieldAssign//sourceId:184217_1
        }
        if (receptionServiceRes_13 != null) {
            retData.setReleaseEffectObj(receptionServiceRes_13.getReleaseEffectObj());//SimpleFieldAssign//sourceId:184216_1
        }
        if (receptionServiceRes_15 != null) {
            retData.setCancelSetCompleteObj(receptionServiceRes_15.getCancelSetCompleteObj());//SimpleFieldAssign//sourceId:184211_1
        }
        if (receptionServiceRes_17 != null) {
            retData.setSetCompleteObj(receptionServiceRes_17.getSetCompleteObj());//SimpleFieldAssign//sourceId:184210_1
        }
        if (receptionServiceRes_19 != null) {
            retData.setCancelRevisionObj(receptionServiceRes_19.getCancelRevisionObj());//SimpleFieldAssign//sourceId:184215_1
        }
        if (receptionServiceRes_21 != null) {
            retData.setChangeRecordObj(receptionServiceRes_21.getChangeRecordObj());//SimpleFieldAssign//sourceId:184214_1
        }
        if (receptionServiceRes_27 != null) {
            retData.setFirstOperation(receptionServiceRes_27.getFirstOperation());//SimpleFieldAssign//sourceId:199335_1
        }
        if (receptionServiceRes_29 != null) {
            retData.setTrailingOperation(receptionServiceRes_29.getTrailingOperation());//SimpleFieldAssign//sourceId:199334_1
        }
        if (receptionServiceRes_31 != null) {
            retData.setMixtureOperation(receptionServiceRes_31.getMixtureOperation());//SimpleFieldAssign//sourceId:199333_1
        }
        if (receptionServiceRes_33 != null) {
            retData.setDeptStartMgt(receptionServiceRes_33.getDeptStartMgt());//SimpleFieldAssign//sourceId:245619_1
        }
        if (receptionServiceRes_35 != null) {
            retData.setDeptOperation(receptionServiceRes_35.getDeptOperation());//SimpleFieldAssign//sourceId:254950_1
        }
        if (receptionServiceRes_37 != null) {
            retData.setDeptPreserveAchieve(receptionServiceRes_37.getDeptPreserveAchieve());//SimpleFieldAssign//sourceId:245618_1
        }
        if (receptionServiceRes_39 != null) {
            retData.setDeptChangeRecordObj(receptionServiceRes_39.getDeptChangeRecordObj());//SimpleFieldAssign//sourceId:261689_1
        }
        if (receptionServiceRes_59 != null) {
            retData.setMemtMgtSence(receptionServiceRes_59.getMemtMgtSence());//SimpleFieldAssign//sourceId:262781_1
        }
        if (receptionServiceRes_61 != null) {
            retData.setMemtMgtSence(receptionServiceRes_61.getMemtMgtSence());//SimpleFieldAssign//sourceId:262781_1
        }
        if (receptionServiceRes_63 != null) {
            retData.setMemtMgtSence(receptionServiceRes_63.getMemtMgtSence());//SimpleFieldAssign//sourceId:262781_1
        }
        if (receptionServiceRes_65 != null) {
            retData.setMemtMgtSence(receptionServiceRes_65.getMemtMgtSence());//SimpleFieldAssign//sourceId:262781_1
        }


        return retData;
    }

    /**
     * 1111D1-1发布底层框架服务批次	[921]
     * gen by moon at 10/2/2022, 7:50:40 AM
     */
    @Trace(operationName = "1111D1-1发布底层框架服务批次	")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReleaseBaseBatchRespDto releaseBaseBatch(ReleaseBaseBatchReqDto reqDto) {


        //virtualUsage 通过批次ID，查出批次ID对应的用途类型编码、归属对象ID  1511
        Batch batch = null;
        QueryBaseBatchDetailReq queryBaseBatchDetailReq = new QueryBaseBatchDetailReq();
        if (reqDto != null) {
            queryBaseBatchDetailReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:19801_1_1511
        }

        /*通过批次ID，查出批次ID对应的用途类型编码、归属对象ID[44]   */
        Assert.isNull(queryBaseBatchDetailReq.getBatchId(), "1111D1-1发布底层框架服务批次	-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-批次ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getSpaceId(), "1111D1-1发布底层框架服务批次	-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-创建于空间ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getAppId(), "1111D1-1发布底层框架服务批次	-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-创建于联盟应用ID不能为空", false);
        batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);


//virtualUsage 通过用途类型编码、归属对象ID查询出当前有效的批次ID  1512
        Batch batch_2 = null;
        if (batch != null) {
            QueryBaseBatchDetailReq queryBaseBatchDetailReq_1 = new QueryBaseBatchDetailReq();
            queryBaseBatchDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:17506_1_1512
            if (batch != null) {
                queryBaseBatchDetailReq_1.setPurposeTypeCode(batch.getPurposeTypeCode());//SimpleFieldAssign//sourceId:17500_1_1512
                queryBaseBatchDetailReq_1.setAscriptionObjectId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:17501_1_1512
            }

            /*通过用途类型编码、归属对象ID查询出当前有效的批次ID[44]   */
            Assert.isNull(queryBaseBatchDetailReq_1.getPurposeTypeCode(), "1111D1-1发布底层框架服务批次	-通过用途类型编码、归属对象ID查询出当前有效的批次ID-用途类型编码不能为空", false);
            Assert.isNull(queryBaseBatchDetailReq_1.getAscriptionObjectId(), "1111D1-1发布底层框架服务批次	-通过用途类型编码、归属对象ID查询出当前有效的批次ID-归属对象ID不能为空", false);
            Assert.isNull(queryBaseBatchDetailReq_1.getSubjectLifeCycle(), "1111D1-1发布底层框架服务批次	-通过用途类型编码、归属对象ID查询出当前有效的批次ID-主体生命周期不能为空", false);
            batch_2 = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq_1);


        }
//virtualUsage 修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是  1513
        boolean bOOLEAN;
        if (batch_2 != null) {
            Batch batch_4 = new Batch();
            batch_4.setBatchEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:17497_1_1513
            batch_4.setSubjectLifeCycle("ARCHIVING");//sourceId:17498_1_1513
            batch_4.setIsArchive("TRUE");//sourceId:17516_1_1513
            batch_4.setIsEditing("FALSE");//sourceId:48237_1_1513
            if (batch_2 != null) {
                batch_4.setBatchId(batch_2.getBatchId());//SimpleFieldAssign//sourceId:17493_1_1513
            }

            /*修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是[42]   */
            Assert.isNull(batch_4.getBatchId(), "1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-批次ID不能为空", false);
            Assert.isNull(batch_4.getBatchEndTime(), "1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-批次结束时间不能为空", false);
            Assert.isNull(batch_4.getSubjectLifeCycle(), "1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-主体生命周期不能为空", false);
            Assert.isNull(batch_4.getIsArchive(), "1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-是否存档不能为空", false);
            Assert.isNull(batch_4.getIsEditing(), "1111D1-1发布底层框架服务批次	-修改当前有效批次主体生命周期为历史存档、批次结束时间为当前时间，是否存档为是-是否未来不能为空", false);
            bOOLEAN = mBatchService.updateBaseBatch(batch_4);


        }
//virtualUsage 修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间  1514
        boolean bOOLEAN_1;
        Batch batch_5 = new Batch();
        batch_5.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:17541_1_1514
        batch_5.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:17543_1_1514
        batch_5.setIsEditing("FALSE");//sourceId:149690_1_1514
        if (reqDto != null) {
            batch_5.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:17538_1_1514
        }

        /*修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间[42]   */
        Assert.isNull(batch_5.getBatchId(), "1111D1-1发布底层框架服务批次	-修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间-批次ID不能为空", false);
        Assert.isNull(batch_5.getBatchStartTime(), "1111D1-1发布底层框架服务批次	-修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间-批次开始时间不能为空", false);
        Assert.isNull(batch_5.getSubjectLifeCycle(), "1111D1-1发布底层框架服务批次	-修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间-主体生命周期不能为空", false);
        Assert.isNull(batch_5.getIsEditing(), "1111D1-1发布底层框架服务批次	-修改正在编辑批次主体生命周期为当前有效、批次开始时间为当前时间-是否未来不能为空", false);
        bOOLEAN_1 = mBatchService.updateBaseBatch(batch_5);


//virtualUsage D2-3查询组织架构模式配置  5666
        QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto = null;
        QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto = new QueryItemMatchResultToAnswerDetailComReqDto();
        queryItemMatchResultToAnswerDetailComReqDto.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:105255_1_5666
        queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:105256_1_5666
        queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:105257_1_5666

        /*D2-3查询组织架构模式配置[3094]   */
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getConfItemCode(), "1111D1-1发布底层框架服务批次	-D2-3查询组织架构模式配置-配置项标识不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjType(), "1111D1-1发布底层框架服务批次	-D2-3查询组织架构模式配置-答案归属对象类型不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "1111D1-1发布底层框架服务批次	-D2-3查询组织架构模式配置-答案归属对象ID不能为空", false);
        queryItemMatchResultToAnswerDetailComRespDto = confSchemeService.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto).getData();


//virtualUsage 组织架构发布中临时自动锁定-暂停对外使用  4347
        boolean bOOLEAN_2;
        if (batch != null) {
            Organization organization = new Organization();
            organization.setUsingLockStatus("AUTO_LOCK");//sourceId:48254_1_4347
            organization.setReasonOfUsingLock("组织架构正在维护，暂停使用，请耐心等待～");//CUSTOM_CONVENTION//sourceId:172601_1_4347
            if (batch != null) {
                organization.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48251_1_4347
            }

            /*组织架构发布中临时自动锁定-暂停对外使用[197]   */
            Assert.isNull(organization.getOrganizationId(), "1111D1-1发布底层框架服务批次	-组织架构发布中临时自动锁定-暂停对外使用-组织ID不能为空", false);
            Assert.isNull(organization.getUsingLockStatus(), "1111D1-1发布底层框架服务批次	-组织架构发布中临时自动锁定-暂停对外使用-使用锁定状态不能为空", false);
            Assert.isNull(organization.getReasonOfUsingLock(), "1111D1-1发布底层框架服务批次	-组织架构发布中临时自动锁定-暂停对外使用-使用锁定原因不能为空", false);
            bOOLEAN_2 = mOrganizationService.updateOrg(organization);


        }
//virtualUsage 查询本次新增的就职记录列表  1517
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        if (batch != null) {
            QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
            queryInductionRecordListReq.setUpdateStatus("NEW");//sourceId:48328_1_1517
            if (batch != null) {
                queryInductionRecordListReq.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48325_1_1517
            }

            /*查询本次新增的就职记录列表[166]   */
            Assert.isNull(queryInductionRecordListReq.getOrganizationId(), "1111D1-1发布底层框架服务批次	-查询本次新增的就职记录列表-组织ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq.getUpdateStatus(), "1111D1-1发布底层框架服务批次	-查询本次新增的就职记录列表-批次下更新状态不能为空", false);
            listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


        }
//virtualUsage 查询新增组织就职记录列表  1579
        List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
        if (batch != null) {
            QueryInductionRecordListReq queryInductionRecordListReq_1 = new QueryInductionRecordListReq();
            queryInductionRecordListReq_1.setInductionUnitTypeCode("ORG");//sourceId:49231_1_1579
            queryInductionRecordListReq_1.setUpdateStatus("NEW");//sourceId:49234_1_1579
            if (batch != null) {
                queryInductionRecordListReq_1.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:49232_1_1579
            }

            /*查询新增组织就职记录列表[166]   */
            Assert.isNull(queryInductionRecordListReq_1.getOrganizationId(), "1111D1-1发布底层框架服务批次	-查询新增组织就职记录列表-组织ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq_1.getInductionUnitTypeCode(), "1111D1-1发布底层框架服务批次	-查询新增组织就职记录列表-就职单位类型实例不能为空", false);
            Assert.isNull(queryInductionRecordListReq_1.getUpdateStatus(), "1111D1-1发布底层框架服务批次	-查询新增组织就职记录列表-批次下更新状态不能为空", false);
            listInductionRecord_2 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1);


        }
//virtualUsage 查询新增部门就职记录列表  1580
        List<InductionRecord> listInductionRecord_4 = new ArrayList<>();
        if (batch != null) {
            QueryInductionRecordListReq queryInductionRecordListReq_2 = new QueryInductionRecordListReq();
            queryInductionRecordListReq_2.setInductionUnitTypeCode("DEPT");//sourceId:49235_1_1580
            queryInductionRecordListReq_2.setUpdateStatus("NEW");//sourceId:49237_1_1580
            if (batch != null) {
                queryInductionRecordListReq_2.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:49236_1_1580
            }

            /*查询新增部门就职记录列表[166]   */
            Assert.isNull(queryInductionRecordListReq_2.getOrganizationId(), "1111D1-1发布底层框架服务批次	-查询新增部门就职记录列表-组织ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq_2.getInductionUnitTypeCode(), "1111D1-1发布底层框架服务批次	-查询新增部门就职记录列表-就职单位类型实例不能为空", false);
            Assert.isNull(queryInductionRecordListReq_2.getUpdateStatus(), "1111D1-1发布底层框架服务批次	-查询新增部门就职记录列表-批次下更新状态不能为空", false);
            listInductionRecord_4 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_2);


        }
//virtualUsage 查询本次修订的就职记录列表  1518
        List<InductionRecord> listInductionRecord_6 = new ArrayList<>();
        if (batch != null) {
            QueryInductionRecordListReq queryInductionRecordListReq_3 = new QueryInductionRecordListReq();
            queryInductionRecordListReq_3.setUpdateStatus("REVISION");//sourceId:48362_1_1518
            if (batch != null) {
                queryInductionRecordListReq_3.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48361_1_1518
            }

            /*查询本次修订的就职记录列表[166]   */
            Assert.isNull(queryInductionRecordListReq_3.getOrganizationId(), "1111D1-1发布底层框架服务批次	-查询本次修订的就职记录列表-组织ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq_3.getUpdateStatus(), "1111D1-1发布底层框架服务批次	-查询本次修订的就职记录列表-批次下更新状态不能为空", false);
            listInductionRecord_6 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_3);


        }
//virtualUsage 查询本次存档的就职记录列表  1560
        List<InductionRecord> listInductionRecord_8 = new ArrayList<>();
        if (batch != null) {
            QueryInductionRecordListReq queryInductionRecordListReq_4 = new QueryInductionRecordListReq();
            queryInductionRecordListReq_4.setUpdateStatus("ARCHIVE");//sourceId:48397_1_1560
            if (batch != null) {
                queryInductionRecordListReq_4.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48396_1_1560
            }

            /*查询本次存档的就职记录列表[166]   */
            Assert.isNull(queryInductionRecordListReq_4.getOrganizationId(), "1111D1-1发布底层框架服务批次	-查询本次存档的就职记录列表-组织ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq_4.getUpdateStatus(), "1111D1-1发布底层框架服务批次	-查询本次存档的就职记录列表-批次下更新状态不能为空", false);
            listInductionRecord_8 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_4);


        }
//virtualUsage 1-1-02批量查询变更字段列表ByIds  1561
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        if (listInductionRecord_6 != null && listInductionRecord_6.size() > 0) {
            BatchQueryBaseChangeColListByIdsReq batchQueryBaseChangeColListByIdsReq = new BatchQueryBaseChangeColListByIdsReq();
            batchQueryBaseChangeColListByIdsReq.setChangeEntityId(listInductionRecord_6.stream().map(item -> item.getInductionRecordId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:48474_1_1561
            batchQueryBaseChangeColListByIdsReq.setTableTypeCode("OMS_ORG_INDUCTION_RECORD");//sourceId:48473_1_1561
            batchQueryBaseChangeColListByIdsReq.setIsInproperties("TRUE");//sourceId:48482_1_1561
            batchQueryBaseChangeColListByIdsReq.setSubjectLifeCycle("EDITING");//sourceId:48477_1_1561
            batchQueryBaseChangeColListByIdsReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:48518_1_1561

            /*1-1-02批量查询变更字段列表ByIds[310]   */
            Assert.isNull(batchQueryBaseChangeColListByIdsReq.getTableTypeCode(), "1111D1-1发布底层框架服务批次	-1-1-02批量查询变更字段列表ByIds-内容表类型编码不能为空", false);
            Assert.isNull(batchQueryBaseChangeColListByIdsReq.getIsInproperties(), "1111D1-1发布底层框架服务批次	-1-1-02批量查询变更字段列表ByIds-是否内部属性不能为空", false);
            Assert.isNull(batchQueryBaseChangeColListByIdsReq.getSubjectLifeCycle(), "1111D1-1发布底层框架服务批次	-1-1-02批量查询变更字段列表ByIds-主体生命周期不能为空", false);
            Assert.isNull(batchQueryBaseChangeColListByIdsReq.getSpaceId(), "1111D1-1发布底层框架服务批次	-1-1-02批量查询变更字段列表ByIds-创建于空间ID不能为空", false);
            listChangeColumn = mChangeColumnService.batchQueryBaseChangeColListByIds(batchQueryBaseChangeColListByIdsReq);


        }
//virtualUsage M合并就职记录变更字段列表  1520
        //ModelCode: mergeChangeColumnList
        MergeChangeColumnIrListRespDto mergeChangeColumnListRes = null;
        if (listInductionRecord_6 != null && listInductionRecord_6.size() > 0 && listChangeColumn != null && listChangeColumn.size() > 0) {
            MergeChangeColumnIrListReqDto mergeChangeColumnListReq = new MergeChangeColumnIrListReqDto();
            mergeChangeColumnListReq.setOrgInductionRecordList(listInductionRecord_6.stream().map(item -> BeanUtil.toBean(item, OrgInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:48418_1_1520
            mergeChangeColumnListReq.setMergeInductionRecordList(//objList-to-objLists
                    listChangeColumn.stream().map(item -> {
                        MergeInductionRecordDto elm = new MergeInductionRecordDto();
                        elm.setInductionRecordId(item.getEntityId());//SimpleFieldAssign//sourceId:23703_2_1520
                        elm.setDirectorInductionRecordId(item.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:23702_2_1520
                        return elm;
                    }).collect(Collectors.toList()));//objList-to-objLists//sourceId:48419_1_1520

            /*M合并就职记录变更字段列表[1646]  通过合并标识，将第二个数据集的数据覆盖第一个数据集数据 */

            mergeChangeColumnListRes = nbBatch.mergeChangeColumnIrList(mergeChangeColumnListReq);


        }
//virtualUsage 1-1-02批量改底层变更字段  1562
        boolean bOOLEAN_3;
        if (listChangeColumn != null && listChangeColumn.size() > 0) {
            List<ChangeColumn> listChangeColumn_2 = new ArrayList<>();
            listChangeColumn_2 = //objList-to-objLists
                    listChangeColumn.stream().map(item -> {
                        ChangeColumn elm = new ChangeColumn();
                        elm.setChangeColumnId(item.getChangeColumnId());//SimpleFieldAssign//sourceId:69576_2_1562
                        elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:69581_2_1562
                        elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:69579_2_1562
                        return elm;
                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:152018_1_1562

            /*1-1-02批量改底层变更字段[1630]   */

            bOOLEAN_3 = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_2);


        }
//virtualUsage 批量改本次新增就职记录  1563
        boolean bOOLEAN_4;
        if (listInductionRecord != null && listInductionRecord.size() > 0) {
            List<InductionRecord> listInductionRecord_10 = new ArrayList<>();
            listInductionRecord_10 = //objList-to-objLists
                    listInductionRecord.stream().map(item -> {
                        InductionRecord elm = new InductionRecord();
                        elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23975_2_1563
                        elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:23977_2_1563
                        elm.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:23978_2_1563
                        elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:23979_2_1563
                        elm.setIsArchive("FALSE");//sourceId:23980_2_1563
                        elm.setArchivngType("NOT_ARCHIVE");//sourceId:23981_2_1563
                        elm.setIsEditing("TRUE");//sourceId:23982_2_1563
                        elm.setIsUpdate("FALSE");//sourceId:23983_2_1563
                        elm.setUpdateStatus("UNCHANGED");//sourceId:23984_2_1563
                        return elm;
                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:48695_1_1563

            /*批量改本次新增就职记录[1647]   */

            bOOLEAN_4 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_10);


        }
//virtualUsage 批量改就职记录状态（重置本次修订）  1522
        boolean bOOLEAN_5;
        List<InductionRecord> listInductionRecord_11 = new ArrayList<>();
        if (mergeChangeColumnListRes != null) {
            listInductionRecord_11 = //objList-to-objLists
                    mergeChangeColumnListRes.getOrgInductionRecordList().stream().map(item -> {
                        InductionRecord elm = new InductionRecord();
                        elm.setIsUpdate("FALSE");//sourceId:23736_2_1522
                        elm.setUpdateStatus("UNCHANGED");//sourceId:23737_2_1522
                        if (item != null) {
                            elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23728_2_1522
                            elm.setDirectorInductionRecordId(item.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:23729_2_1522
                        }
                        return elm;
                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:48423_1_1522
        }

        /*批量改就职记录状态（重置本次修订）[1647]   */

        bOOLEAN_5 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_11);


//virtualUsage 批量改就职记录状态为历史存档  1523
        boolean bOOLEAN_6;
        if (listInductionRecord_8 != null && listInductionRecord_8.size() > 0) {
            List<InductionRecord> listInductionRecord_12 = new ArrayList<>();
            listInductionRecord_12 = //objList-to-objLists
                    listInductionRecord_8.stream().map(item -> {
                        InductionRecord elm = new InductionRecord();
                        elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23738_2_1523
                        elm.setBatchEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:23741_2_1523
                        elm.setSubjectLifeCycle("ARCHIVING");//sourceId:23742_2_1523
                        elm.setIsArchive("TRUE");//sourceId:23743_2_1523
                        elm.setArchivngType("ARCHIVED");//sourceId:23744_2_1523
                        elm.setIsEditing("FALSE");//sourceId:23745_2_1523
                        elm.setIsUpdate("FALSE");//sourceId:23746_2_1523
                        elm.setUpdateStatus("UNCHANGED");//sourceId:23747_2_1523
                        return elm;
                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:48424_1_1523

            /*批量改就职记录状态为历史存档[1647]   */

            bOOLEAN_6 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_12);


        }
//virtualUsage 查询存档就职记录的分配权限  1524
        List<PrivacyDistribution> listPrivacyDistribution = new ArrayList<>();
        if (listInductionRecord_8 != null && listInductionRecord_8.size() > 0) {
            BatchQueryTributPowerListReq batchQueryTributPowerListReq = new BatchQueryTributPowerListReq();
            batchQueryTributPowerListReq.setTributPowerList(listInductionRecord_8.stream().map(item -> item.getInductionRecordId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:48426_1_1524
            batchQueryTributPowerListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:48428_1_1524
            batchQueryTributPowerListReq.setTypeCode("PERSONAL_DEPARTMENT");//sourceId:48425_1_1524

            /*查询存档就职记录的分配权限[702]   */
            Assert.isNull(batchQueryTributPowerListReq.getSubjectLifeCycle(), "1111D1-1发布底层框架服务批次	-查询存档就职记录的分配权限-主体生命周期不能为空", false);
            Assert.isNull(batchQueryTributPowerListReq.getTypeCode(), "1111D1-1发布底层框架服务批次	-查询存档就职记录的分配权限-分配对象类型编码不能为空", false);
            listPrivacyDistribution = mPrivacyDistributionService.batchQueryTributPowerList(batchQueryTributPowerListReq);


        }
//virtualUsage 批量存档就职记录的分配权限  1525
        boolean bOOLEAN_7;
        if (listPrivacyDistribution != null && listPrivacyDistribution.size() > 0) {
            List<PrivacyDistribution> listPrivacyDistribution_2 = new ArrayList<>();
            listPrivacyDistribution_2 = //objList-to-objLists
                    listPrivacyDistribution.stream().map(item -> {
                        PrivacyDistribution elm = new PrivacyDistribution();
                        elm.setPrivacyDistributionId(item.getPrivacyDistributionId());//SimpleFieldAssign//sourceId:23752_2_1525
                        elm.setSubjectLifeCycle("ARCHIVING");//sourceId:24026_2_1525
                        elm.setIsArchive("TRUE");//sourceId:24027_2_1525
                        return elm;
                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:48429_1_1525

            /*批量存档就职记录的分配权限[1554]   */

            bOOLEAN_7 = mPrivacyDistributionService.batchUpdateTributPower(listPrivacyDistribution_2);


        }
//virtualUsage D1-1修改检查项状态(公共)  8670
        UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
        if (batch != null) {
            UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto = new UpdateCheckItemStatComReqDto();
            updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:144881_1_8670
            updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:144882_1_8670
            updateCheckItemStatComReqDto.setIsComplete("TRUE");//sourceId:144880_1_8670
            if (batch != null) {
                updateCheckItemStatComReqDto.setEntityId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:144883_1_8670
            }

            /*D1-1修改检查项状态(公共)[947]   */
            Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(), "1111D1-1发布底层框架服务批次	-D1-1修改检查项状态(公共)-检查项标识不能为空", false);
            Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(), "1111D1-1发布底层框架服务批次	-D1-1修改检查项状态(公共)-内容对象类型编码不能为空", false);
            Assert.isNull(updateCheckItemStatComReqDto.getEntityId(), "1111D1-1发布底层框架服务批次	-D1-1修改检查项状态(公共)-内容对象实例ID不能为空", false);
            Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(), "1111D1-1发布底层框架服务批次	-D1-1修改检查项状态(公共)-是否已完成不能为空", false);
            updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);


        }
//virtualUsage M-循环存档部门职务（特殊方法）  2138
        //ModelCode: circulationCollections
        for (InductionRecord circulationCollectionsRes : listInductionRecord_8) {

//virtualUsage 查询部门职务关系ID下是否还有就职记录  2139
            List<InductionRecord> listInductionRecord_13 = new ArrayList<>();
            QueryInductionRecordListReq queryInductionRecordListReq_5 = new QueryInductionRecordListReq();
            queryInductionRecordListReq_5.setIsArchive("FALSE");//sourceId:55559_1_2139
            if (circulationCollectionsRes != null) {
                queryInductionRecordListReq_5.setDeptPositionRelationshipId(circulationCollectionsRes.getDeptPositionRelationshipId());//SimpleFieldAssign//sourceId:55558_1_2139
            }

            /*查询部门职务关系ID下是否还有就职记录[166]   */
            Assert.isNull(queryInductionRecordListReq_5.getDeptPositionRelationshipId(), "1111D1-1发布底层框架服务批次	-查询部门职务关系ID下是否还有就职记录-冗余部门职务关系ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq_5.getIsArchive(), "1111D1-1发布底层框架服务批次	-查询部门职务关系ID下是否还有就职记录-是否存档不能为空", false);
            listInductionRecord_13 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_5);


//virtualUsage 查询职务是否存档  2140
            Position position = null;
            QueryPositionDetailReq queryPositionDetailReq = new QueryPositionDetailReq();
            queryPositionDetailReq.setSubjectLifeCycle("ARCHIVING");//sourceId:55577_1_2140
            if (circulationCollectionsRes != null) {
                queryPositionDetailReq.setPositionId(circulationCollectionsRes.getPositionId());//SimpleFieldAssign//sourceId:55560_1_2140
            }

            /*查询职务是否存档[146]   */
            Assert.isNull(queryPositionDetailReq.getPositionId(), "1111D1-1发布底层框架服务批次	-查询职务是否存档-职务ID不能为空", false);
            Assert.isNull(queryPositionDetailReq.getSubjectLifeCycle(), "1111D1-1发布底层框架服务批次	-查询职务是否存档-主体生命周期不能为空", false);
            position = mPositionService.queryPositionDetail(queryPositionDetailReq);


            if ((listInductionRecord_13 != null && listInductionRecord_13 != null && listInductionRecord_13.size() == 0 && listInductionRecord_13 != null && listInductionRecord_13 != null && listInductionRecord_13.size() == 0 && position != null)) {
                //if((查询部门职务关系ID下是否还有就职记录.就职记录列表数据集条数 等于 0 and 查询空间下该职务是否已存档.出参 值不等于空 ))  2147

                boolean bOOLEAN_8;
                DeptPositionRelationship deptPositionRelationship = new DeptPositionRelationship();
                deptPositionRelationship.setSubjectLifeCycle("ARCHIVING");//sourceId:55595_1_2148
                deptPositionRelationship.setIsArchive("TRUE");//sourceId:55596_1_2148
                if (circulationCollectionsRes != null) {
                    deptPositionRelationship.setOrgPositionRelationshipId(circulationCollectionsRes.getDeptPositionRelationshipId());//SimpleFieldAssign//sourceId:55589_1_2148
                }

                /*存档当前部门职务关系ID[1641]   */
                Assert.isNull(deptPositionRelationship.getOrgPositionRelationshipId(), "1111D1-1发布底层框架服务批次	-存档当前部门职务关系ID-组织职务关系ID不能为空", false);
                Assert.isNull(deptPositionRelationship.getSubjectLifeCycle(), "1111D1-1发布底层框架服务批次	-存档当前部门职务关系ID-主体生命周期不能为空", false);
                Assert.isNull(deptPositionRelationship.getIsArchive(), "1111D1-1发布底层框架服务批次	-存档当前部门职务关系ID-是否存档不能为空", false);
                bOOLEAN_8 = mDeptPositionRelationshipService.updateOrgDeptPosition(deptPositionRelationship);


                List<PrivacyDistribution> listPrivacyDistribution_3 = new ArrayList<>();
                QueryTributPowerListReq queryTributPowerListReq = new QueryTributPowerListReq();
                queryTributPowerListReq.setTypeCode("DEPARTMENT_POSITION");//sourceId:55615_1_2149
                queryTributPowerListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:55617_1_2149
                if (circulationCollectionsRes != null) {
                    queryTributPowerListReq.setAllocationObjectId(circulationCollectionsRes.getDeptPositionRelationshipId());//SimpleFieldAssign//sourceId:55616_1_2149
                }

                /*查询存档部门职务关系ID的分配权限列表[497]   */
                Assert.isNull(queryTributPowerListReq.getTypeCode(), "1111D1-1发布底层框架服务批次	-查询存档部门职务关系ID的分配权限列表-分配对象类型编码不能为空", false);
                Assert.isNull(queryTributPowerListReq.getAllocationObjectId(), "1111D1-1发布底层框架服务批次	-查询存档部门职务关系ID的分配权限列表-分配对象ID不能为空", false);
                Assert.isNull(queryTributPowerListReq.getSubjectLifeCycle(), "1111D1-1发布底层框架服务批次	-查询存档部门职务关系ID的分配权限列表-主体生命周期不能为空", false);
                listPrivacyDistribution_3 = mPrivacyDistributionService.queryTributPowerList(queryTributPowerListReq);


                boolean bOOLEAN_9;
                if (listPrivacyDistribution_3 != null && listPrivacyDistribution_3.size() > 0) {
                    List<PrivacyDistribution> listPrivacyDistribution_5 = new ArrayList<>();
                    listPrivacyDistribution_5 = //objList-to-objLists
                            listPrivacyDistribution_3.stream().map(item -> {
                                PrivacyDistribution elm = new PrivacyDistribution();
                                elm.setPrivacyDistributionId(item.getPrivacyDistributionId());//SimpleFieldAssign//sourceId:30363_2_2150
                                elm.setSubjectLifeCycle("ARCHIVING");//sourceId:30364_2_2150
                                elm.setIsArchive("TRUE");//sourceId:30365_2_2150
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:55614_1_2150

                    /*存档部门职务关系ID的分配权限[1554]   */

                    bOOLEAN_9 = mPrivacyDistributionService.batchUpdateTributPower(listPrivacyDistribution_5);


                }
            }
//virtualUsage M-循环结束（特殊方法）  2146
            //ModelCode: circulationEnd
        }

        if ((queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG"))) {
            //if(D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 等于 无组织架构)  1526

            boolean bOOLEAN_10;
            if (listInductionRecord != null && listInductionRecord.size() > 0) {
                List<Staffing> listStaffing = new ArrayList<>();
                listStaffing = //objList-to-objLists
                        listInductionRecord.stream().map(item -> {
                            Staffing elm = new Staffing();
                            elm.setStaffingId(item.getStaffingId());//SimpleFieldAssign//sourceId:23684_2_1527
                            elm.setInductionState("TRUE");//sourceId:23687_2_1527
                            elm.setTempLock("FALSE");//sourceId:23688_2_1527
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:48399_1_1527

                /*本次新增就职记录更新编制[931]   */

                bOOLEAN_10 = mStaffingService.batchUpdateStaffing(listStaffing);


            }
//ModelCode: circulationCollections
            for (InductionRecord circulationCollectionsRes_2 : listInductionRecord) {

                Staffing staffing = null;
                QueryStaffingDetailReq queryStaffingDetailReq = new QueryStaffingDetailReq();
                if (circulationCollectionsRes_2 != null) {
                    queryStaffingDetailReq.setStaffingId(circulationCollectionsRes_2.getStaffingId());//SimpleFieldAssign//sourceId:53983_1_2064
                }

                /*查询发牌编制的编制账户ID[191]   */
                Assert.isNull(queryStaffingDetailReq.getStaffingId(), "1111D1-1发布底层框架服务批次	-查询发牌编制的编制账户ID-编制ID不能为空", false);
                staffing = mStaffingService.queryStaffingDetail(queryStaffingDetailReq);


//ModelCode: getDataCount
                AddCalculationAddAndSubRespDto getDataCountRes = null;
                if (staffing != null) {
                    AddCalculationAddAndSubReqDto getDataCountReq = new AddCalculationAddAndSubReqDto();
                    if (staffing != null) {
                        getDataCountReq.setStaffingId(staffing.getStaffingAccountId());//SimpleFieldAssign//sourceId:54074_1_2065
                    }

                    /*M计算发牌编制账户在职加减数量1（特殊方法）[1746]  入参一个数据集，返回数据集条数 */
                    Assert.isNull(getDataCountReq.getStaffingId(), "1111D1-1发布底层框架服务批次	-M计算发牌编制账户在职加减数量1（特殊方法）-编制ID不能为空", false);
                    getDataCountRes = nbBatch.addCalculationAddAndSub(getDataCountReq);


                }
                boolean bOOLEAN_11;
                if (staffing != null) {
                    StaffingAccount staffingAccount = new StaffingAccount();
                    if (staffing != null) {
                        staffingAccount.setStaffingAccountId(staffing.getStaffingAccountId());//SimpleFieldAssign//sourceId:54034_1_2066
                    }
                    if (getDataCountRes != null) {
                        staffingAccount.setActualStaffingNumber(getDataCountRes.getStaffingNum());//SimpleFieldAssign//sourceId:54035_1_2066
                        staffingAccount.setVacantStaffingNumber(getDataCountRes.getStaffingNum());//SimpleFieldAssign//sourceId:54036_1_2066
                    }

                    /*1-3-14加减更新发牌编制账户的在职子账户加减数量1[1780]   */
                    Assert.isNull(staffingAccount.getStaffingAccountId(), "1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的在职子账户加减数量1-编制账户ID不能为空", false);
                    Assert.isNull(staffingAccount.getActualStaffingNumber(), "1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的在职子账户加减数量1-冗余编制在职数量不能为空", false);
                    Assert.isNull(staffingAccount.getVacantStaffingNumber(), "1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的在职子账户加减数量1-空缺编制数量不能为空", false);
                    bOOLEAN_11 = mStaffingAccountService.updateStaffOnAcntNum(staffingAccount);


                }
//ModelCode: circulationEnd
            }

            boolean bOOLEAN_12;
            if (listInductionRecord_8 != null && listInductionRecord_8.size() > 0) {
                List<Staffing> listStaffing_1 = new ArrayList<>();
                listStaffing_1 = //objList-to-objLists
                        listInductionRecord_8.stream().map(item -> {
                            Staffing elm = new Staffing();
                            elm.setStaffingId(item.getStaffingId());//SimpleFieldAssign//sourceId:23689_2_1528
                            elm.setInductionState("FALSE");//sourceId:23690_2_1528
                            elm.setTempLock("FALSE");//sourceId:23691_2_1528
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:48411_1_1528

                /*批量本次存档就职记录释放及解锁编制ID列表[931]   */

                bOOLEAN_12 = mStaffingService.batchUpdateStaffing(listStaffing_1);


            }
//ModelCode: circulationCollections
            for (InductionRecord circulationCollectionsRes_4 : listInductionRecord_8) {

                Staffing staffing_2 = null;
                QueryStaffingDetailReq queryStaffingDetailReq_1 = new QueryStaffingDetailReq();
                if (circulationCollectionsRes_4 != null) {
                    queryStaffingDetailReq_1.setStaffingId(circulationCollectionsRes_4.getStaffingId());//SimpleFieldAssign//sourceId:54071_1_2069
                }

                /*查询存档编制详情[191]   */

                staffing_2 = mStaffingService.queryStaffingDetail(queryStaffingDetailReq_1);


//ModelCode: getDataCount
                AddCalculationAddAndSubRespDto getDataCountRes_2 = null;
                if (staffing_2 != null) {
                    AddCalculationAddAndSubReqDto getDataCountReq_1 = new AddCalculationAddAndSubReqDto();
                    if (staffing_2 != null) {
                        getDataCountReq_1.setStaffingId(staffing_2.getStaffingAccountId());//SimpleFieldAssign//sourceId:54020_1_2070
                    }

                    /*M计算存档数值（特殊方法）11[1746]  入参一个数据集，返回数据集条数 */
                    Assert.isNull(getDataCountReq_1.getStaffingId(), "1111D1-1发布底层框架服务批次	-M计算存档数值（特殊方法）11-编制ID不能为空", false);
                    getDataCountRes_2 = nbBatch.addCalculationAddAndSub(getDataCountReq_1);


                }
                boolean bOOLEAN_13;
                if (staffing_2 != null) {
                    StaffingAccount staffingAccount_1 = new StaffingAccount();
                    if (staffing_2 != null) {
                        staffingAccount_1.setStaffingAccountId(staffing_2.getStaffingAccountId());//SimpleFieldAssign//sourceId:54093_1_2071
                    }
                    if (getDataCountRes_2 != null) {
                        staffingAccount_1.setActualStaffingNumber(getDataCountRes_2.getStaffingNum());//SimpleFieldAssign//sourceId:54094_1_2071
                    }
//if(getDataCountRes!=null){
//      staffingAccount_1.setVacantStaffingNumber(getDataCountRes.getStaffingNum());//SimpleFieldAssign//sourceId:54095_1_2071
//    }

                    /*1-3-14加减更新发牌编制账户的空缺子账户加减数量1[1781]   */
                    Assert.isNull(staffingAccount_1.getStaffingAccountId(), "1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的空缺子账户加减数量1-编制账户ID不能为空", false);
                    Assert.isNull(staffingAccount_1.getActualStaffingNumber(), "1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的空缺子账户加减数量1-冗余编制在职数量不能为空", false);
                    Assert.isNull(staffingAccount_1.getVacantStaffingNumber(), "1111D1-1发布底层框架服务批次	-1-3-14加减更新发牌编制账户的空缺子账户加减数量1-空缺编制数量不能为空", false);
                    bOOLEAN_13 = mStaffingAccountService.updateStaffOffAcntNum(staffingAccount_1);


                }
//ModelCode: circulationEnd
            }

            boolean bOOLEAN_14;
            if (listInductionRecord_2 != null && listInductionRecord_2.size() > 0) {
                List<DeptPositionRelationship> listDeptPositionRelationship = new ArrayList<>();
                listDeptPositionRelationship = //objList-to-objLists
                        listInductionRecord_2.stream().map(item -> {
                            DeptPositionRelationship elm = new DeptPositionRelationship();
                            elm.setPositionId(item.getPositionId());//SimpleFieldAssign//sourceId:24507_2_1581
                            elm.setOrgEntityId(item.getEntityId());//SimpleFieldAssign//sourceId:24509_2_1581
                            elm.setOrgTypeCode("ORGANIZATION");//sourceId:24508_2_1581
                            elm.setOrganizationId(item.getOrganizationId());//SimpleFieldAssign//sourceId:24510_2_1581
                            elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:24513_2_1581
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:49162_1_1581

                /*批量新增组织职务关系ID[1497]   */

                bOOLEAN_14 = mDeptPositionRelationshipService.batchAddDeptPosition(listDeptPositionRelationship);


            }
            boolean bOOLEAN_15;
            if (listInductionRecord_4 != null && listInductionRecord_4.size() > 0) {
                List<DeptPositionRelationship> listDeptPositionRelationship_1 = new ArrayList<>();
                listDeptPositionRelationship_1 = //objList-to-objLists
                        listInductionRecord_4.stream().map(item -> {
                            DeptPositionRelationship elm = new DeptPositionRelationship();
                            elm.setPositionId(item.getPositionId());//SimpleFieldAssign//sourceId:24519_2_1582
                            elm.setOrgEntityId(item.getEntityId());//SimpleFieldAssign//sourceId:24521_2_1582
                            elm.setOrgTypeCode("DEPARTMENT");//sourceId:24520_2_1582
                            elm.setOrganizationId(item.getOrganizationId());//SimpleFieldAssign//sourceId:24522_2_1582
                            elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:24525_2_1582
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:49164_1_1582

                /*批量新增部门职务关系ID[1497]   */

                bOOLEAN_15 = mDeptPositionRelationshipService.batchAddDeptPosition(listDeptPositionRelationship_1);


            }
            boolean bOOLEAN_16;
            if (batch != null) {
                Organization organization_1 = new Organization();
                organization_1.setUsingLockStatus("UNLOCK");//sourceId:48451_1_1529
                organization_1.setReasonOfUsingLock("---");//NULL//sourceId:172615_1_1529
                if (batch != null) {
                    organization_1.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48447_1_1529
                }

                /*组织架构使用自动锁定-对外恢复正常使用[197]   */
                Assert.isNull(organization_1.getOrganizationId(), "1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-组织ID不能为空", false);
                Assert.isNull(organization_1.getUsingLockStatus(), "1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-使用锁定状态不能为空", false);
                Assert.isNull(organization_1.getReasonOfUsingLock(), "1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-使用锁定原因不能为空", false);
                Assert.isNull(organization_1.getCurrentManageObjectType(), "1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-当前管理对象类型不能为空", false);
                bOOLEAN_16 = mOrganizationService.updateOrg(organization_1);


            }
//ModelCode: batchClearUserInfoFromRedis
            BatchClearUserInfoFromRedisRespDto batchClearUserInfoFromRedisRes = null;
            if (listInductionRecord_8 != null && listInductionRecord_8.size() > 0) {
                BatchClearUserInfoFromRedisReqDto batchClearUserInfoFromRedisReq = new BatchClearUserInfoFromRedisReqDto();
                batchClearUserInfoFromRedisReq.setBeginMemberList(listInductionRecord_8.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51052_1_1697

                /*M-Redis批量清空用户信息（特殊方法）[1695]  入参身份ID数据集，清除用户就职信息缓存 */

                batchClearUserInfoFromRedisRes = nbBatch.batchClearUserInfoFromRedis(batchClearUserInfoFromRedisReq);


            }
//processBranchName:正常结束 ,processBranchId:1530

        } else {
            //else  1531

            boolean bOOLEAN_17;
            if (batch != null) {
                Organization organization_2 = new Organization();
                organization_2.setUsingLockStatus("UNLOCK");//sourceId:48451_1_1532
                organization_2.setReasonOfUsingLock("---");//NULL//sourceId:172615_1_1532
                if (batch != null) {
                    organization_2.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48447_1_1532
                }

                /*组织架构使用自动锁定-对外恢复正常使用[197]   */
                Assert.isNull(organization_2.getOrganizationId(), "1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-组织ID不能为空", false);
                Assert.isNull(organization_2.getUsingLockStatus(), "1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-使用锁定状态不能为空", false);
                Assert.isNull(organization_2.getReasonOfUsingLock(), "1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-使用锁定原因不能为空", false);
                Assert.isNull(organization_2.getCurrentManageObjectType(), "1111D1-1发布底层框架服务批次	-组织架构使用自动锁定-对外恢复正常使用-当前管理对象类型不能为空", false);
                bOOLEAN_17 = mOrganizationService.updateOrg(organization_2);


            }
//ModelCode: batchClearUserInfoFromRedis
            BatchClearUserInfoFromRedisRespDto batchClearUserInfoFromRedisRes_1 = null;
            if (listInductionRecord_8 != null && listInductionRecord_8.size() > 0) {
                BatchClearUserInfoFromRedisReqDto batchClearUserInfoFromRedisReq_1 = new BatchClearUserInfoFromRedisReqDto();
                batchClearUserInfoFromRedisReq_1.setBeginMemberList(listInductionRecord_8.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51052_1_1698

                /*M-Redis批量清空用户信息（特殊方法）[1695]  入参身份ID数据集，清除用户就职信息缓存 */

                batchClearUserInfoFromRedisRes_1 = nbBatch.batchClearUserInfoFromRedis(batchClearUserInfoFromRedisReq_1);


            }
//processBranchName:正常结束 ,processBranchId:1533

        }
        ReleaseBaseBatchRespDto retData = new ReleaseBaseBatchRespDto();


        return retData;
    }

    /**
     * 1111D1-1删除底层框架服务批次[936]
     * gen by moon at 10/2/2022, 7:51:21 AM
     */
    @Trace(operationName = "1111D1-1删除底层框架服务批次")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteBaseBatchRespDto deleteBaseBatch(DeleteBaseBatchReqDto reqDto) {


        //virtualUsage 通过批次ID，查出批次ID对应的用途类型编码、归属对象ID  1539
        Batch batch = null;
        QueryBaseBatchDetailReq queryBaseBatchDetailReq = new QueryBaseBatchDetailReq();
        if (reqDto != null) {
            queryBaseBatchDetailReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:19760_1_1539
        }

        /*通过批次ID，查出批次ID对应的用途类型编码、归属对象ID[44]   */
        Assert.isNull(queryBaseBatchDetailReq.getSpaceId(), "1111D1-1删除底层框架服务批次-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-创建于空间ID不能为空", false);
        Assert.isNull(queryBaseBatchDetailReq.getAppId(), "1111D1-1删除底层框架服务批次-通过批次ID，查出批次ID对应的用途类型编码、归属对象ID-创建于联盟应用ID不能为空", false);
        batch = mBatchService.queryBaseBatchDetail(queryBaseBatchDetailReq);


//virtualUsage 1-1-01删除底层框架服务批次	  1540
        boolean bOOLEAN;
        String string = new String();
        if (reqDto != null) {
            string = reqDto.getBatchId();
            ;//SimpleFieldAssign//sourceId:23734_1_1540
        }

        /*1-1-01删除底层框架服务批次	[43]   */
        Assert.isNull(string, "1111D1-1删除底层框架服务批次-1-1-01删除底层框架服务批次	-批次ID不能为空", false);
        bOOLEAN = mBatchService.deleteBaseBatch(string);


//virtualUsage D2-3查询配置项匹配结果转答案(公共)  5667
        QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto = null;
        QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto = new QueryItemMatchResultToAnswerDetailComReqDto();
        queryItemMatchResultToAnswerDetailComReqDto.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:105308_1_5667
        queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:105309_1_5667
        queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:105310_1_5667

        /*D2-3查询配置项匹配结果转答案(公共)[3094]   */
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getConfItemCode(), "1111D1-1删除底层框架服务批次-D2-3查询配置项匹配结果转答案(公共)-配置项标识不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjType(), "1111D1-1删除底层框架服务批次-D2-3查询配置项匹配结果转答案(公共)-答案归属对象类型不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "1111D1-1删除底层框架服务批次-D2-3查询配置项匹配结果转答案(公共)-答案归属对象ID不能为空", false);
        queryItemMatchResultToAnswerDetailComRespDto = confSchemeService.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto).getData();


//virtualUsage 修改组织临时冻结  1543
        boolean bOOLEAN_1;
        if (batch != null) {
            Organization organization = new Organization();
            organization.setManageLockStatus("TRUE");//sourceId:48570_1_1543
//organization.setReasonOfManageLock();//AUTOMATIC_STAY  TODO ruizhe dong//sourceId:48571_1_1543
            organization.setUsingLockStatus("TRUE");//sourceId:48572_1_1543
            if (batch != null) {
                organization.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48569_1_1543
            }

            /*修改组织临时冻结[197]   */

            bOOLEAN_1 = mOrganizationService.updateOrg(organization);


        }
//virtualUsage 查询本次新增的就职记录列表  1544
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        if (batch != null) {
            QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
            queryInductionRecordListReq.setUpdateStatus("NEW");//sourceId:48688_1_1544
            if (batch != null) {
                queryInductionRecordListReq.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48687_1_1544
            }

            /*查询本次新增的就职记录列表[166]   */
            Assert.isNull(queryInductionRecordListReq.getOrganizationId(), "1111D1-1删除底层框架服务批次-查询本次新增的就职记录列表-组织ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq.getUpdateStatus(), "1111D1-1删除底层框架服务批次-查询本次新增的就职记录列表-批次下更新状态不能为空", false);
            listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


        }
//virtualUsage 查询本次修订的就职记录列表  1545
        List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
        if (batch != null) {
            QueryInductionRecordListReq queryInductionRecordListReq_1 = new QueryInductionRecordListReq();
            queryInductionRecordListReq_1.setUpdateStatus("REVISION");//sourceId:48690_1_1545
            if (batch != null) {
                queryInductionRecordListReq_1.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48689_1_1545
            }

            /*查询本次修订的就职记录列表[166]   */

            listInductionRecord_2 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1);


        }
//virtualUsage 1-1-02批量查询变更字段列表ByIds  1564
        List<ChangeColumn> listChangeColumn = new ArrayList<>();
        if (listInductionRecord_2 != null && listInductionRecord_2.size() > 0) {
            BatchQueryBaseChangeColListByIdsReq batchQueryBaseChangeColListByIdsReq = new BatchQueryBaseChangeColListByIdsReq();
            batchQueryBaseChangeColListByIdsReq.setTableTypeCode("CUSTOM_CONVENTION");//sourceId:48788_1_1564
            batchQueryBaseChangeColListByIdsReq.setChangeEntityId(listInductionRecord_2.stream().map(item -> item.getInductionRecordId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:48789_1_1564
            batchQueryBaseChangeColListByIdsReq.setIsInproperties("TRUE");//sourceId:48797_1_1564
            batchQueryBaseChangeColListByIdsReq.setSubjectLifeCycle("EDITING");//sourceId:48792_1_1564
            batchQueryBaseChangeColListByIdsReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:48798_1_1564
            batchQueryBaseChangeColListByIdsReq.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:48799_1_1564

            /*1-1-02批量查询变更字段列表ByIds[310]   */
            Assert.isNull(batchQueryBaseChangeColListByIdsReq.getTableTypeCode(), "1111D1-1删除底层框架服务批次-1-1-02批量查询变更字段列表ByIds-内容表类型编码不能为空", false);
            listChangeColumn = mChangeColumnService.batchQueryBaseChangeColListByIds(batchQueryBaseChangeColListByIdsReq);


        }
//virtualUsage 1-1-02批量删除底层框架服务变更字段  1565
        boolean bOOLEAN_2;
        if (listChangeColumn != null && listChangeColumn.size() > 0) {
            List<String> listString = new ArrayList<>();
            listString = listChangeColumn.stream().map(item -> item.getChangeColumnId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:48521_1_1565

            /*1-1-02批量删除底层框架服务变更字段[7]   */

            bOOLEAN_2 = mChangeColumnService.batchDeleteBaseChangeColumn(listString);


        }
//virtualUsage 查询本次存档的就职记录列表  1546
        List<InductionRecord> listInductionRecord_4 = new ArrayList<>();
        if (batch != null) {
            QueryInductionRecordListReq queryInductionRecordListReq_2 = new QueryInductionRecordListReq();
            queryInductionRecordListReq_2.setUpdateStatus("ARCHIVE");//sourceId:48692_1_1546
            if (batch != null) {
                queryInductionRecordListReq_2.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48691_1_1546
            }

            /*查询本次存档的就职记录列表[166]   */

            listInductionRecord_4 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_2);


        }
//virtualUsage 1-3-13批量删除就职记录  5484
        boolean bOOLEAN_3;
        if (listInductionRecord != null && listInductionRecord.size() > 0) {
            List<String> listString_1 = new ArrayList<>();
            listString_1 = listInductionRecord.stream().map(item -> item.getInductionRecordId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:102891_1_5484

            /*1-3-13批量删除就职记录[1685]   */

            bOOLEAN_3 = mInductionRecordService.batchDeleteInductionRecord(listString_1);


        }
//virtualUsage 修改本次修订就职记录  1548
        boolean bOOLEAN_4;
        if (listInductionRecord_2 != null && listInductionRecord_2.size() > 0) {
            List<InductionRecord> listInductionRecord_6 = new ArrayList<>();
            listInductionRecord_6 = //objList-to-objLists
                    listInductionRecord_2.stream().map(item -> {
                        InductionRecord elm = new InductionRecord();
                        elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23964_2_1548
                        elm.setIsUpdate("FALSE");//sourceId:23972_2_1548
                        elm.setUpdateStatus("UNCHANGED");//sourceId:23973_2_1548
                        return elm;
                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:48693_1_1548

            /*修改本次修订就职记录[1647]   */

            bOOLEAN_4 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_6);


        }
//virtualUsage 修改本次存档就职记录  1549
        boolean bOOLEAN_5;
        if (listInductionRecord_4 != null && listInductionRecord_4.size() > 0) {
            List<InductionRecord> listInductionRecord_7 = new ArrayList<>();
            listInductionRecord_7 = //objList-to-objLists
                    listInductionRecord_4.stream().map(item -> {
                        InductionRecord elm = new InductionRecord();
                        elm.setInductionRecordId(item.getInductionRecordId());//SimpleFieldAssign//sourceId:23986_2_1549
                        elm.setArchivngType("NOT_ARCHIVE");//sourceId:23992_2_1549
                        elm.setIsUpdate("FALSE");//sourceId:23994_2_1549
                        elm.setUpdateStatus("UNCHANGED");//sourceId:23995_2_1549
                        return elm;
                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:48697_1_1549

            /*修改本次存档就职记录[1647]   */

            bOOLEAN_5 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_7);


        }
//virtualUsage D1-1修改检查项状态(公共)  8671
        UpdateCheckItemStatComRespDto updateCheckItemStatComRespDto = null;
        if (batch != null) {
            UpdateCheckItemStatComReqDto updateCheckItemStatComReqDto = new UpdateCheckItemStatComReqDto();
            updateCheckItemStatComReqDto.setCheckItemCode("ORG_MEMBER_CHECK");//CUSTOM_CONVENTION//sourceId:144897_1_8671
            updateCheckItemStatComReqDto.setObjectTypeCode("ORG_CHECK");//sourceId:144898_1_8671
            updateCheckItemStatComReqDto.setIsComplete("TRUE");//sourceId:144896_1_8671
            if (batch != null) {
                updateCheckItemStatComReqDto.setEntityId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:144899_1_8671
            }

            /*D1-1修改检查项状态(公共)[947]   */
            Assert.isNull(updateCheckItemStatComReqDto.getCheckItemCode(), "1111D1-1删除底层框架服务批次-D1-1修改检查项状态(公共)-检查项标识不能为空", false);
            Assert.isNull(updateCheckItemStatComReqDto.getObjectTypeCode(), "1111D1-1删除底层框架服务批次-D1-1修改检查项状态(公共)-内容对象类型编码不能为空", false);
            Assert.isNull(updateCheckItemStatComReqDto.getEntityId(), "1111D1-1删除底层框架服务批次-D1-1修改检查项状态(公共)-内容对象实例ID不能为空", false);
            Assert.isNull(updateCheckItemStatComReqDto.getIsComplete(), "1111D1-1删除底层框架服务批次-D1-1修改检查项状态(公共)-是否已完成不能为空", false);
            updateCheckItemStatComRespDto = offStateService.updateCheckItemStatCom(updateCheckItemStatComReqDto);


        }
        if ((queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("PLAN_STAFFING"))) {
            //if(D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 等于 计划编制型)  5367

            boolean bOOLEAN_6;
            if (listInductionRecord != null && listInductionRecord.size() > 0) {
                List<Staffing> listStaffing = new ArrayList<>();
                listStaffing = //objList-to-objLists
                        listInductionRecord.stream().map(item -> {
                            Staffing elm = new Staffing();
                            elm.setStaffingId(item.getStaffingId());//SimpleFieldAssign//sourceId:23996_2_5368
                            elm.setInductionState("FALSE");//sourceId:23997_2_5368
                            elm.setTempLock("FALSE");//sourceId:23998_2_5368
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:48698_1_5368

                /*本次新增就职记录更新编制[931]   */

                bOOLEAN_6 = mStaffingService.batchUpdateStaffing(listStaffing);


            }
            boolean bOOLEAN_7;
            if (batch != null) {
                Organization organization_1 = new Organization();
                organization_1.setManageLockStatus("FALSE");//sourceId:48716_1_5369
                organization_1.setUsingLockStatus("FALSE");//sourceId:48718_1_5369
                if (batch != null) {
                    organization_1.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48715_1_5369
                }

                /*修改组织取消临时冻结[197]   */
                Assert.isNull(organization_1.getOrganizationId(), "1111D1-1删除底层框架服务批次-修改组织取消临时冻结-组织ID不能为空", false);
                Assert.isNull(organization_1.getManageLockStatus(), "1111D1-1删除底层框架服务批次-修改组织取消临时冻结-管理锁定状态不能为空", false);
                Assert.isNull(organization_1.getReasonOfManageLock(), "1111D1-1删除底层框架服务批次-修改组织取消临时冻结-管理锁定原因不能为空", false);
                Assert.isNull(organization_1.getUsingLockStatus(), "1111D1-1删除底层框架服务批次-修改组织取消临时冻结-使用锁定状态不能为空", false);
                bOOLEAN_7 = mOrganizationService.updateOrg(organization_1);


            }
//processBranchName:正常结束 ,processBranchId:5370

        } else {
            //else  1554

            boolean bOOLEAN_8;
            if (batch != null) {
                Organization organization_2 = new Organization();
                organization_2.setManageLockStatus("FALSE");//sourceId:48716_1_1555
                organization_2.setUsingLockStatus("FALSE");//sourceId:48718_1_1555
                if (batch != null) {
                    organization_2.setOrganizationId(batch.getAscriptionObjectId());//SimpleFieldAssign//sourceId:48715_1_1555
                }

                /*修改组织取消临时冻结[197]   */
                Assert.isNull(organization_2.getOrganizationId(), "1111D1-1删除底层框架服务批次-修改组织取消临时冻结-组织ID不能为空", false);
                Assert.isNull(organization_2.getManageLockStatus(), "1111D1-1删除底层框架服务批次-修改组织取消临时冻结-管理锁定状态不能为空", false);
                Assert.isNull(organization_2.getReasonOfManageLock(), "1111D1-1删除底层框架服务批次-修改组织取消临时冻结-管理锁定原因不能为空", false);
                Assert.isNull(organization_2.getUsingLockStatus(), "1111D1-1删除底层框架服务批次-修改组织取消临时冻结-使用锁定状态不能为空", false);
                bOOLEAN_8 = mOrganizationService.updateOrg(organization_2);


            }
//processBranchName:正常结束 ,processBranchId:1556

        }
        DeleteBaseBatchRespDto retData = new DeleteBaseBatchRespDto();


        return retData;
    }

    /**
     * D1执行生命周期判断(公共)[7830]
     * gen by moon at 11/10/2023, 3:05:44 PM
     */
    @Trace(operationName = "D1执行生命周期判断(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementLifeCycleJudgmentComRespDto implementLifeCycleJudgmentCom(ImplementLifeCycleJudgmentComReqDto reqDto) {


        if ((reqDto != null && reqDto.getLifecyCycleOperationType() != null && reqDto.getLifecyCycleOperationType().equals("DELETE"))) {
            //if(D3执行生命周期判断(公共).生命周期操作类型 等于 删除)  52446

            if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID") || reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("ARCHIVING"))) {
                //if((D3执行生命周期判断(公共).主体生命周期 等于 当前有效 or D3执行生命周期判断(公共).主体生命周期 等于 历史存档))  52452

//异常结束 52461
                throw new BizException("3P10100267", "对不起不可操作！～因为当前状态不对，请手动刷新页面～。", false);
            }
        } else if ((reqDto != null && reqDto.getLifecyCycleOperationType() != null && reqDto.getLifecyCycleOperationType().equals("ARCHIVE"))) {
            //elseif(D3执行生命周期判断(公共).生命周期操作类型 等于 存档)  52447

            if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("EDITING") || reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("ARCHIVING"))) {
                //if((D3执行生命周期判断(公共).主体生命周期 等于 正在编辑 or D3执行生命周期判断(公共).主体生命周期 等于 历史存档))  52454

//异常结束 52462
                throw new BizException("3P10100267", "对不起不可操作！～因为当前状态不对，请手动刷新页面～。", false);
            }
        } else if ((reqDto != null && reqDto.getLifecyCycleOperationType() != null && reqDto.getLifecyCycleOperationType().equals("UNDO_ARCHIVE"))) {
            //elseif(D3执行生命周期判断(公共).生命周期操作类型 等于 撤销存档)  52448

            if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID") || reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
                //if((D3执行生命周期判断(公共).主体生命周期 等于 当前有效 or D3执行生命周期判断(公共).主体生命周期 等于 正在编辑))  52460

//异常结束 52463
                throw new BizException("3P10100267", "对不起不可操作！～因为当前状态不对，请手动刷新页面～。", false);
            }
        } else {
            //else  52449

//异常结束 52450
            throw new BizException("500", "系统异常，请联系管理员！", false);
        }
        ImplementLifeCycleJudgmentComRespDto retData = new ImplementLifeCycleJudgmentComRespDto();


        return retData;
    }

    //
}